diff options
Diffstat (limited to 'include')
115 files changed, 1846 insertions, 847 deletions
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h index c34b11022908..c65e4ce6c3af 100644 --- a/include/acpi/acpi_bus.h +++ b/include/acpi/acpi_bus.h | |||
@@ -114,10 +114,13 @@ struct acpi_device_ops { | |||
114 | acpi_op_notify notify; | 114 | acpi_op_notify notify; |
115 | }; | 115 | }; |
116 | 116 | ||
117 | #define ACPI_DRIVER_ALL_NOTIFY_EVENTS 0x1 /* system AND device events */ | ||
118 | |||
117 | struct acpi_driver { | 119 | struct acpi_driver { |
118 | char name[80]; | 120 | char name[80]; |
119 | char class[80]; | 121 | char class[80]; |
120 | const struct acpi_device_id *ids; /* Supported Hardware IDs */ | 122 | const struct acpi_device_id *ids; /* Supported Hardware IDs */ |
123 | unsigned int flags; | ||
121 | struct acpi_device_ops ops; | 124 | struct acpi_device_ops ops; |
122 | struct device_driver drv; | 125 | struct device_driver drv; |
123 | struct module *owner; | 126 | struct module *owner; |
@@ -168,7 +171,7 @@ struct acpi_device_dir { | |||
168 | 171 | ||
169 | /* Plug and Play */ | 172 | /* Plug and Play */ |
170 | 173 | ||
171 | typedef char acpi_bus_id[5]; | 174 | typedef char acpi_bus_id[8]; |
172 | typedef unsigned long acpi_bus_address; | 175 | typedef unsigned long acpi_bus_address; |
173 | typedef char acpi_hardware_id[15]; | 176 | typedef char acpi_hardware_id[15]; |
174 | typedef char acpi_unique_id[9]; | 177 | typedef char acpi_unique_id[9]; |
@@ -365,10 +368,10 @@ struct acpi_bus_type { | |||
365 | int register_acpi_bus_type(struct acpi_bus_type *); | 368 | int register_acpi_bus_type(struct acpi_bus_type *); |
366 | int unregister_acpi_bus_type(struct acpi_bus_type *); | 369 | int unregister_acpi_bus_type(struct acpi_bus_type *); |
367 | struct device *acpi_get_physical_device(acpi_handle); | 370 | struct device *acpi_get_physical_device(acpi_handle); |
368 | struct device *acpi_get_physical_pci_device(acpi_handle); | ||
369 | 371 | ||
370 | /* helper */ | 372 | /* helper */ |
371 | acpi_handle acpi_get_child(acpi_handle, acpi_integer); | 373 | acpi_handle acpi_get_child(acpi_handle, acpi_integer); |
374 | int acpi_is_root_bridge(acpi_handle); | ||
372 | acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int); | 375 | acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int); |
373 | #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle)) | 376 | #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle)) |
374 | 377 | ||
diff --git a/include/acpi/acpi_drivers.h b/include/acpi/acpi_drivers.h index 0352c8f0b05b..f4906f6568d4 100644 --- a/include/acpi/acpi_drivers.h +++ b/include/acpi/acpi_drivers.h | |||
@@ -57,8 +57,7 @@ | |||
57 | */ | 57 | */ |
58 | 58 | ||
59 | #define ACPI_POWER_HID "LNXPOWER" | 59 | #define ACPI_POWER_HID "LNXPOWER" |
60 | #define ACPI_PROCESSOR_OBJECT_HID "ACPI_CPU" | 60 | #define ACPI_PROCESSOR_OBJECT_HID "LNXCPU" |
61 | #define ACPI_PROCESSOR_HID "ACPI0007" | ||
62 | #define ACPI_SYSTEM_HID "LNXSYSTM" | 61 | #define ACPI_SYSTEM_HID "LNXSYSTM" |
63 | #define ACPI_THERMAL_HID "LNXTHERM" | 62 | #define ACPI_THERMAL_HID "LNXTHERM" |
64 | #define ACPI_BUTTON_HID_POWERF "LNXPWRBN" | 63 | #define ACPI_BUTTON_HID_POWERF "LNXPWRBN" |
@@ -91,17 +90,15 @@ int acpi_pci_link_free_irq(acpi_handle handle); | |||
91 | 90 | ||
92 | /* ACPI PCI Interrupt Routing (pci_irq.c) */ | 91 | /* ACPI PCI Interrupt Routing (pci_irq.c) */ |
93 | 92 | ||
94 | int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus); | 93 | int acpi_pci_irq_add_prt(acpi_handle handle, struct pci_bus *bus); |
95 | void acpi_pci_irq_del_prt(int segment, int bus); | 94 | void acpi_pci_irq_del_prt(struct pci_bus *bus); |
96 | 95 | ||
97 | /* ACPI PCI Device Binding (pci_bind.c) */ | 96 | /* ACPI PCI Device Binding (pci_bind.c) */ |
98 | 97 | ||
99 | struct pci_bus; | 98 | struct pci_bus; |
100 | 99 | ||
101 | acpi_status acpi_get_pci_id(acpi_handle handle, struct acpi_pci_id *id); | 100 | struct pci_dev *acpi_get_pci_dev(acpi_handle); |
102 | int acpi_pci_bind(struct acpi_device *device); | 101 | int acpi_pci_bind_root(struct acpi_device *device); |
103 | int acpi_pci_bind_root(struct acpi_device *device, struct acpi_pci_id *id, | ||
104 | struct pci_bus *bus); | ||
105 | 102 | ||
106 | /* Arch-defined function to add a bus to the system */ | 103 | /* Arch-defined function to add a bus to the system */ |
107 | 104 | ||
diff --git a/include/acpi/processor.h b/include/acpi/processor.h index 4927c063347c..baf1e0a9a7ee 100644 --- a/include/acpi/processor.h +++ b/include/acpi/processor.h | |||
@@ -258,6 +258,7 @@ DECLARE_PER_CPU(struct acpi_processor *, processors); | |||
258 | extern struct acpi_processor_errata errata; | 258 | extern struct acpi_processor_errata errata; |
259 | 259 | ||
260 | void arch_acpi_processor_init_pdc(struct acpi_processor *pr); | 260 | void arch_acpi_processor_init_pdc(struct acpi_processor *pr); |
261 | void arch_acpi_processor_cleanup_pdc(struct acpi_processor *pr); | ||
261 | 262 | ||
262 | #ifdef ARCH_HAS_POWER_INIT | 263 | #ifdef ARCH_HAS_POWER_INIT |
263 | void acpi_processor_power_init_bm_check(struct acpi_processor_flags *flags, | 264 | void acpi_processor_power_init_bm_check(struct acpi_processor_flags *flags, |
diff --git a/include/acpi/video.h b/include/acpi/video.h index af6fe95fd3d0..cf7be3dd157b 100644 --- a/include/acpi/video.h +++ b/include/acpi/video.h | |||
@@ -3,10 +3,10 @@ | |||
3 | 3 | ||
4 | #if (defined CONFIG_ACPI_VIDEO || defined CONFIG_ACPI_VIDEO_MODULE) | 4 | #if (defined CONFIG_ACPI_VIDEO || defined CONFIG_ACPI_VIDEO_MODULE) |
5 | extern int acpi_video_register(void); | 5 | extern int acpi_video_register(void); |
6 | extern int acpi_video_exit(void); | 6 | extern void acpi_video_unregister(void); |
7 | #else | 7 | #else |
8 | static inline int acpi_video_register(void) { return 0; } | 8 | static inline int acpi_video_register(void) { return 0; } |
9 | static inline void acpi_video_exit(void) { return; } | 9 | static inline void acpi_video_unregister(void) { return; } |
10 | #endif | 10 | #endif |
11 | 11 | ||
12 | #endif | 12 | #endif |
diff --git a/include/asm-generic/hardirq.h b/include/asm-generic/hardirq.h index 3d5d2c906ab3..23bb4dad4962 100644 --- a/include/asm-generic/hardirq.h +++ b/include/asm-generic/hardirq.h | |||
@@ -11,19 +11,6 @@ typedef struct { | |||
11 | 11 | ||
12 | #include <linux/irq_cpustat.h> /* Standard mappings for irq_cpustat_t above */ | 12 | #include <linux/irq_cpustat.h> /* Standard mappings for irq_cpustat_t above */ |
13 | 13 | ||
14 | #ifndef HARDIRQ_BITS | ||
15 | #define HARDIRQ_BITS 8 | ||
16 | #endif | ||
17 | |||
18 | /* | ||
19 | * The hardirq mask has to be large enough to have | ||
20 | * space for potentially all IRQ sources in the system | ||
21 | * nesting on a single CPU: | ||
22 | */ | ||
23 | #if (1 << HARDIRQ_BITS) < NR_IRQS | ||
24 | # error HARDIRQ_BITS is too low! | ||
25 | #endif | ||
26 | |||
27 | #ifndef ack_bad_irq | 14 | #ifndef ack_bad_irq |
28 | static inline void ack_bad_irq(unsigned int irq) | 15 | static inline void ack_bad_irq(unsigned int irq) |
29 | { | 16 | { |
diff --git a/include/asm-generic/kmap_types.h b/include/asm-generic/kmap_types.h index 54e8b3d956b7..eddbce0f9fb9 100644 --- a/include/asm-generic/kmap_types.h +++ b/include/asm-generic/kmap_types.h | |||
@@ -24,7 +24,10 @@ D(12) KM_SOFTIRQ1, | |||
24 | D(13) KM_SYNC_ICACHE, | 24 | D(13) KM_SYNC_ICACHE, |
25 | D(14) KM_SYNC_DCACHE, | 25 | D(14) KM_SYNC_DCACHE, |
26 | D(15) KM_UML_USERCOPY, /* UML specific, for copy_*_user - used in do_op_one_page */ | 26 | D(15) KM_UML_USERCOPY, /* UML specific, for copy_*_user - used in do_op_one_page */ |
27 | D(16) KM_TYPE_NR | 27 | D(16) KM_IRQ_PTE, |
28 | D(17) KM_NMI, | ||
29 | D(18) KM_NMI_PTE, | ||
30 | D(19) KM_TYPE_NR | ||
28 | }; | 31 | }; |
29 | 32 | ||
30 | #undef D | 33 | #undef D |
diff --git a/include/asm-generic/pgtable.h b/include/asm-generic/pgtable.h index e410f602cab1..e2bd73e8f9c0 100644 --- a/include/asm-generic/pgtable.h +++ b/include/asm-generic/pgtable.h | |||
@@ -129,6 +129,10 @@ static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addres | |||
129 | #define move_pte(pte, prot, old_addr, new_addr) (pte) | 129 | #define move_pte(pte, prot, old_addr, new_addr) (pte) |
130 | #endif | 130 | #endif |
131 | 131 | ||
132 | #ifndef pgprot_noncached | ||
133 | #define pgprot_noncached(prot) (prot) | ||
134 | #endif | ||
135 | |||
132 | #ifndef pgprot_writecombine | 136 | #ifndef pgprot_writecombine |
133 | #define pgprot_writecombine pgprot_noncached | 137 | #define pgprot_writecombine pgprot_noncached |
134 | #endif | 138 | #endif |
diff --git a/include/asm-generic/uaccess.h b/include/asm-generic/uaccess.h index 6d8cab22e294..b218b8513d04 100644 --- a/include/asm-generic/uaccess.h +++ b/include/asm-generic/uaccess.h | |||
@@ -163,7 +163,7 @@ static inline __must_check long __copy_to_user(void __user *to, | |||
163 | #define put_user(x, ptr) \ | 163 | #define put_user(x, ptr) \ |
164 | ({ \ | 164 | ({ \ |
165 | might_sleep(); \ | 165 | might_sleep(); \ |
166 | __access_ok(ptr, sizeof (*ptr)) ? \ | 166 | access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)) ? \ |
167 | __put_user(x, ptr) : \ | 167 | __put_user(x, ptr) : \ |
168 | -EFAULT; \ | 168 | -EFAULT; \ |
169 | }) | 169 | }) |
@@ -219,7 +219,7 @@ extern int __put_user_bad(void) __attribute__((noreturn)); | |||
219 | #define get_user(x, ptr) \ | 219 | #define get_user(x, ptr) \ |
220 | ({ \ | 220 | ({ \ |
221 | might_sleep(); \ | 221 | might_sleep(); \ |
222 | __access_ok(ptr, sizeof (*ptr)) ? \ | 222 | access_ok(VERIFY_READ, ptr, sizeof(*ptr)) ? \ |
223 | __get_user(x, ptr) : \ | 223 | __get_user(x, ptr) : \ |
224 | -EFAULT; \ | 224 | -EFAULT; \ |
225 | }) | 225 | }) |
@@ -244,7 +244,7 @@ static inline long copy_from_user(void *to, | |||
244 | const void __user * from, unsigned long n) | 244 | const void __user * from, unsigned long n) |
245 | { | 245 | { |
246 | might_sleep(); | 246 | might_sleep(); |
247 | if (__access_ok(from, n)) | 247 | if (access_ok(VERIFY_READ, from, n)) |
248 | return __copy_from_user(to, from, n); | 248 | return __copy_from_user(to, from, n); |
249 | else | 249 | else |
250 | return n; | 250 | return n; |
@@ -254,7 +254,7 @@ static inline long copy_to_user(void __user *to, | |||
254 | const void *from, unsigned long n) | 254 | const void *from, unsigned long n) |
255 | { | 255 | { |
256 | might_sleep(); | 256 | might_sleep(); |
257 | if (__access_ok(to, n)) | 257 | if (access_ok(VERIFY_WRITE, to, n)) |
258 | return __copy_to_user(to, from, n); | 258 | return __copy_to_user(to, from, n); |
259 | else | 259 | else |
260 | return n; | 260 | return n; |
@@ -278,7 +278,7 @@ __strncpy_from_user(char *dst, const char __user *src, long count) | |||
278 | static inline long | 278 | static inline long |
279 | strncpy_from_user(char *dst, const char __user *src, long count) | 279 | strncpy_from_user(char *dst, const char __user *src, long count) |
280 | { | 280 | { |
281 | if (!__access_ok(src, 1)) | 281 | if (!access_ok(VERIFY_READ, src, 1)) |
282 | return -EFAULT; | 282 | return -EFAULT; |
283 | return __strncpy_from_user(dst, src, count); | 283 | return __strncpy_from_user(dst, src, count); |
284 | } | 284 | } |
@@ -291,6 +291,8 @@ strncpy_from_user(char *dst, const char __user *src, long count) | |||
291 | #ifndef strnlen_user | 291 | #ifndef strnlen_user |
292 | static inline long strnlen_user(const char __user *src, long n) | 292 | static inline long strnlen_user(const char __user *src, long n) |
293 | { | 293 | { |
294 | if (!access_ok(VERIFY_READ, src, 1)) | ||
295 | return 0; | ||
294 | return strlen((void * __force)src) + 1; | 296 | return strlen((void * __force)src) + 1; |
295 | } | 297 | } |
296 | #endif | 298 | #endif |
@@ -316,7 +318,7 @@ static inline __must_check unsigned long | |||
316 | clear_user(void __user *to, unsigned long n) | 318 | clear_user(void __user *to, unsigned long n) |
317 | { | 319 | { |
318 | might_sleep(); | 320 | might_sleep(); |
319 | if (!__access_ok(to, n)) | 321 | if (!access_ok(VERIFY_WRITE, to, n)) |
320 | return n; | 322 | return n; |
321 | 323 | ||
322 | return __clear_user(to, n); | 324 | return __clear_user(to, n); |
diff --git a/include/asm-generic/unistd.h b/include/asm-generic/unistd.h index 5b34b6233d6d..1125e5a1ee5d 100644 --- a/include/asm-generic/unistd.h +++ b/include/asm-generic/unistd.h | |||
@@ -618,8 +618,13 @@ __SYSCALL(__NR_migrate_pages, sys_migrate_pages) | |||
618 | __SYSCALL(__NR_move_pages, sys_move_pages) | 618 | __SYSCALL(__NR_move_pages, sys_move_pages) |
619 | #endif | 619 | #endif |
620 | 620 | ||
621 | #define __NR_rt_tgsigqueueinfo 240 | ||
622 | __SYSCALL(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo) | ||
623 | #define __NR_perf_counter_open 241 | ||
624 | __SYSCALL(__NR_perf_counter_open, sys_perf_counter_open) | ||
625 | |||
621 | #undef __NR_syscalls | 626 | #undef __NR_syscalls |
622 | #define __NR_syscalls 240 | 627 | #define __NR_syscalls 242 |
623 | 628 | ||
624 | /* | 629 | /* |
625 | * All syscalls below here should go away really, | 630 | * All syscalls below here should go away really, |
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 55413e568f07..92b73b6140ff 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h | |||
@@ -625,7 +625,7 @@ | |||
625 | *(.init.ramfs) \ | 625 | *(.init.ramfs) \ |
626 | VMLINUX_SYMBOL(__initramfs_end) = .; | 626 | VMLINUX_SYMBOL(__initramfs_end) = .; |
627 | #else | 627 | #else |
628 | #define INITRAMFS | 628 | #define INIT_RAM_FS |
629 | #endif | 629 | #endif |
630 | 630 | ||
631 | /** | 631 | /** |
diff --git a/include/drm/drmP.h b/include/drm/drmP.h index d4ddc22e46bb..45b67d9c39c1 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h | |||
@@ -34,9 +34,6 @@ | |||
34 | #ifndef _DRM_P_H_ | 34 | #ifndef _DRM_P_H_ |
35 | #define _DRM_P_H_ | 35 | #define _DRM_P_H_ |
36 | 36 | ||
37 | /* If you want the memory alloc debug functionality, change define below */ | ||
38 | /* #define DEBUG_MEMORY */ | ||
39 | |||
40 | #ifdef __KERNEL__ | 37 | #ifdef __KERNEL__ |
41 | #ifdef __alpha__ | 38 | #ifdef __alpha__ |
42 | /* add include of current.h so that "current" is defined | 39 | /* add include of current.h so that "current" is defined |
@@ -133,31 +130,6 @@ extern void drm_ut_debug_printk(unsigned int request_level, | |||
133 | 130 | ||
134 | #define DRM_FLAG_DEBUG 0x01 | 131 | #define DRM_FLAG_DEBUG 0x01 |
135 | 132 | ||
136 | #define DRM_MEM_DMA 0 | ||
137 | #define DRM_MEM_SAREA 1 | ||
138 | #define DRM_MEM_DRIVER 2 | ||
139 | #define DRM_MEM_MAGIC 3 | ||
140 | #define DRM_MEM_IOCTLS 4 | ||
141 | #define DRM_MEM_MAPS 5 | ||
142 | #define DRM_MEM_VMAS 6 | ||
143 | #define DRM_MEM_BUFS 7 | ||
144 | #define DRM_MEM_SEGS 8 | ||
145 | #define DRM_MEM_PAGES 9 | ||
146 | #define DRM_MEM_FILES 10 | ||
147 | #define DRM_MEM_QUEUES 11 | ||
148 | #define DRM_MEM_CMDS 12 | ||
149 | #define DRM_MEM_MAPPINGS 13 | ||
150 | #define DRM_MEM_BUFLISTS 14 | ||
151 | #define DRM_MEM_AGPLISTS 15 | ||
152 | #define DRM_MEM_TOTALAGP 16 | ||
153 | #define DRM_MEM_BOUNDAGP 17 | ||
154 | #define DRM_MEM_CTXBITMAP 18 | ||
155 | #define DRM_MEM_STUB 19 | ||
156 | #define DRM_MEM_SGLISTS 20 | ||
157 | #define DRM_MEM_CTXLIST 21 | ||
158 | #define DRM_MEM_MM 22 | ||
159 | #define DRM_MEM_HASHTAB 23 | ||
160 | |||
161 | #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8) | 133 | #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8) |
162 | #define DRM_MAP_HASH_OFFSET 0x10000000 | 134 | #define DRM_MAP_HASH_OFFSET 0x10000000 |
163 | 135 | ||
@@ -1517,24 +1489,6 @@ static __inline__ void drm_core_dropmap(struct drm_local_map *map) | |||
1517 | { | 1489 | { |
1518 | } | 1490 | } |
1519 | 1491 | ||
1520 | #ifndef DEBUG_MEMORY | ||
1521 | /** Wrapper around kmalloc() */ | ||
1522 | static __inline__ void *drm_alloc(size_t size, int area) | ||
1523 | { | ||
1524 | return kmalloc(size, GFP_KERNEL); | ||
1525 | } | ||
1526 | |||
1527 | /** Wrapper around kfree() */ | ||
1528 | static __inline__ void drm_free(void *pt, size_t size, int area) | ||
1529 | { | ||
1530 | kfree(pt); | ||
1531 | } | ||
1532 | |||
1533 | /** Wrapper around kcalloc() */ | ||
1534 | static __inline__ void *drm_calloc(size_t nmemb, size_t size, int area) | ||
1535 | { | ||
1536 | return kcalloc(nmemb, size, GFP_KERNEL); | ||
1537 | } | ||
1538 | 1492 | ||
1539 | static __inline__ void *drm_calloc_large(size_t nmemb, size_t size) | 1493 | static __inline__ void *drm_calloc_large(size_t nmemb, size_t size) |
1540 | { | 1494 | { |
@@ -1555,12 +1509,6 @@ static __inline void drm_free_large(void *ptr) | |||
1555 | 1509 | ||
1556 | vfree(ptr); | 1510 | vfree(ptr); |
1557 | } | 1511 | } |
1558 | #else | ||
1559 | extern void *drm_alloc(size_t size, int area); | ||
1560 | extern void drm_free(void *pt, size_t size, int area); | ||
1561 | extern void *drm_calloc(size_t nmemb, size_t size, int area); | ||
1562 | #endif | ||
1563 | |||
1564 | /*@}*/ | 1512 | /*@}*/ |
1565 | 1513 | ||
1566 | #endif /* __KERNEL__ */ | 1514 | #endif /* __KERNEL__ */ |
diff --git a/include/drm/drm_edid.h b/include/drm/drm_edid.h index a11cc9d32591..7d6c9a2dfcbb 100644 --- a/include/drm/drm_edid.h +++ b/include/drm/drm_edid.h | |||
@@ -28,53 +28,49 @@ | |||
28 | #define EDID_LENGTH 128 | 28 | #define EDID_LENGTH 128 |
29 | #define DDC_ADDR 0x50 | 29 | #define DDC_ADDR 0x50 |
30 | 30 | ||
31 | #ifdef BIG_ENDIAN | ||
32 | #error "EDID structure is little endian, need big endian versions" | ||
33 | #else | ||
34 | |||
35 | struct est_timings { | 31 | struct est_timings { |
36 | u8 t1; | 32 | u8 t1; |
37 | u8 t2; | 33 | u8 t2; |
38 | u8 mfg_rsvd; | 34 | u8 mfg_rsvd; |
39 | } __attribute__((packed)); | 35 | } __attribute__((packed)); |
40 | 36 | ||
37 | /* 00=16:10, 01=4:3, 10=5:4, 11=16:9 */ | ||
38 | #define EDID_TIMING_ASPECT_SHIFT 6 | ||
39 | #define EDID_TIMING_ASPECT_MASK (0x3 << EDID_TIMING_ASPECT_SHIFT) | ||
40 | |||
41 | /* need to add 60 */ | ||
42 | #define EDID_TIMING_VFREQ_SHIFT 0 | ||
43 | #define EDID_TIMING_VFREQ_MASK (0x3f << EDID_TIMING_VFREQ_SHIFT) | ||
44 | |||
41 | struct std_timing { | 45 | struct std_timing { |
42 | u8 hsize; /* need to multiply by 8 then add 248 */ | 46 | u8 hsize; /* need to multiply by 8 then add 248 */ |
43 | u8 vfreq:6; /* need to add 60 */ | 47 | u8 vfreq_aspect; |
44 | u8 aspect_ratio:2; /* 00=16:10, 01=4:3, 10=5:4, 11=16:9 */ | ||
45 | } __attribute__((packed)); | 48 | } __attribute__((packed)); |
46 | 49 | ||
50 | #define DRM_EDID_PT_HSYNC_POSITIVE (1 << 1) | ||
51 | #define DRM_EDID_PT_VSYNC_POSITIVE (1 << 2) | ||
52 | #define DRM_EDID_PT_SEPARATE_SYNC (3 << 3) | ||
53 | #define DRM_EDID_PT_STEREO (1 << 5) | ||
54 | #define DRM_EDID_PT_INTERLACED (1 << 7) | ||
55 | |||
47 | /* If detailed data is pixel timing */ | 56 | /* If detailed data is pixel timing */ |
48 | struct detailed_pixel_timing { | 57 | struct detailed_pixel_timing { |
49 | u8 hactive_lo; | 58 | u8 hactive_lo; |
50 | u8 hblank_lo; | 59 | u8 hblank_lo; |
51 | u8 hblank_hi:4; | 60 | u8 hactive_hblank_hi; |
52 | u8 hactive_hi:4; | ||
53 | u8 vactive_lo; | 61 | u8 vactive_lo; |
54 | u8 vblank_lo; | 62 | u8 vblank_lo; |
55 | u8 vblank_hi:4; | 63 | u8 vactive_vblank_hi; |
56 | u8 vactive_hi:4; | ||
57 | u8 hsync_offset_lo; | 64 | u8 hsync_offset_lo; |
58 | u8 hsync_pulse_width_lo; | 65 | u8 hsync_pulse_width_lo; |
59 | u8 vsync_pulse_width_lo:4; | 66 | u8 vsync_offset_pulse_width_lo; |
60 | u8 vsync_offset_lo:4; | 67 | u8 hsync_vsync_offset_pulse_width_hi; |
61 | u8 vsync_pulse_width_hi:2; | ||
62 | u8 vsync_offset_hi:2; | ||
63 | u8 hsync_pulse_width_hi:2; | ||
64 | u8 hsync_offset_hi:2; | ||
65 | u8 width_mm_lo; | 68 | u8 width_mm_lo; |
66 | u8 height_mm_lo; | 69 | u8 height_mm_lo; |
67 | u8 height_mm_hi:4; | 70 | u8 width_height_mm_hi; |
68 | u8 width_mm_hi:4; | ||
69 | u8 hborder; | 71 | u8 hborder; |
70 | u8 vborder; | 72 | u8 vborder; |
71 | u8 unknown0:1; | 73 | u8 misc; |
72 | u8 hsync_positive:1; | ||
73 | u8 vsync_positive:1; | ||
74 | u8 separate_sync:2; | ||
75 | u8 stereo:1; | ||
76 | u8 unknown6:1; | ||
77 | u8 interlaced:1; | ||
78 | } __attribute__((packed)); | 74 | } __attribute__((packed)); |
79 | 75 | ||
80 | /* If it's not pixel timing, it'll be one of the below */ | 76 | /* If it's not pixel timing, it'll be one of the below */ |
@@ -88,18 +84,16 @@ struct detailed_data_monitor_range { | |||
88 | u8 min_hfreq_khz; | 84 | u8 min_hfreq_khz; |
89 | u8 max_hfreq_khz; | 85 | u8 max_hfreq_khz; |
90 | u8 pixel_clock_mhz; /* need to multiply by 10 */ | 86 | u8 pixel_clock_mhz; /* need to multiply by 10 */ |
91 | u16 sec_gtf_toggle; /* A000=use above, 20=use below */ /* FIXME: byte order */ | 87 | __le16 sec_gtf_toggle; /* A000=use above, 20=use below */ |
92 | u8 hfreq_start_khz; /* need to multiply by 2 */ | 88 | u8 hfreq_start_khz; /* need to multiply by 2 */ |
93 | u8 c; /* need to divide by 2 */ | 89 | u8 c; /* need to divide by 2 */ |
94 | u16 m; /* FIXME: byte order */ | 90 | __le16 m; |
95 | u8 k; | 91 | u8 k; |
96 | u8 j; /* need to divide by 2 */ | 92 | u8 j; /* need to divide by 2 */ |
97 | } __attribute__((packed)); | 93 | } __attribute__((packed)); |
98 | 94 | ||
99 | struct detailed_data_wpindex { | 95 | struct detailed_data_wpindex { |
100 | u8 white_y_lo:2; | 96 | u8 white_yx_lo; /* Lower 2 bits each */ |
101 | u8 white_x_lo:2; | ||
102 | u8 pad:4; | ||
103 | u8 white_x_hi; | 97 | u8 white_x_hi; |
104 | u8 white_y_hi; | 98 | u8 white_y_hi; |
105 | u8 gamma; /* need to divide by 100 then add 1 */ | 99 | u8 gamma; /* need to divide by 100 then add 1 */ |
@@ -134,13 +128,29 @@ struct detailed_non_pixel { | |||
134 | #define EDID_DETAIL_MONITOR_SERIAL 0xff | 128 | #define EDID_DETAIL_MONITOR_SERIAL 0xff |
135 | 129 | ||
136 | struct detailed_timing { | 130 | struct detailed_timing { |
137 | u16 pixel_clock; /* need to multiply by 10 KHz */ /* FIXME: byte order */ | 131 | __le16 pixel_clock; /* need to multiply by 10 KHz */ |
138 | union { | 132 | union { |
139 | struct detailed_pixel_timing pixel_data; | 133 | struct detailed_pixel_timing pixel_data; |
140 | struct detailed_non_pixel other_data; | 134 | struct detailed_non_pixel other_data; |
141 | } data; | 135 | } data; |
142 | } __attribute__((packed)); | 136 | } __attribute__((packed)); |
143 | 137 | ||
138 | #define DRM_EDID_INPUT_SERRATION_VSYNC (1 << 0) | ||
139 | #define DRM_EDID_INPUT_SYNC_ON_GREEN (1 << 1) | ||
140 | #define DRM_EDID_INPUT_COMPOSITE_SYNC (1 << 2) | ||
141 | #define DRM_EDID_INPUT_SEPARATE_SYNCS (1 << 3) | ||
142 | #define DRM_EDID_INPUT_BLANK_TO_BLACK (1 << 4) | ||
143 | #define DRM_EDID_INPUT_VIDEO_LEVEL (3 << 5) | ||
144 | #define DRM_EDID_INPUT_DIGITAL (1 << 7) /* bits below must be zero if set */ | ||
145 | |||
146 | #define DRM_EDID_FEATURE_DEFAULT_GTF (1 << 0) | ||
147 | #define DRM_EDID_FEATURE_PREFERRED_TIMING (1 << 1) | ||
148 | #define DRM_EDID_FEATURE_STANDARD_COLOR (1 << 2) | ||
149 | #define DRM_EDID_FEATURE_DISPLAY_TYPE (3 << 3) /* 00=mono, 01=rgb, 10=non-rgb, 11=unknown */ | ||
150 | #define DRM_EDID_FEATURE_PM_ACTIVE_OFF (1 << 5) | ||
151 | #define DRM_EDID_FEATURE_PM_SUSPEND (1 << 6) | ||
152 | #define DRM_EDID_FEATURE_PM_STANDBY (1 << 7) | ||
153 | |||
144 | struct edid { | 154 | struct edid { |
145 | u8 header[8]; | 155 | u8 header[8]; |
146 | /* Vendor & product info */ | 156 | /* Vendor & product info */ |
@@ -153,25 +163,11 @@ struct edid { | |||
153 | u8 version; | 163 | u8 version; |
154 | u8 revision; | 164 | u8 revision; |
155 | /* Display info: */ | 165 | /* Display info: */ |
156 | /* input definition */ | 166 | u8 input; |
157 | u8 serration_vsync:1; | ||
158 | u8 sync_on_green:1; | ||
159 | u8 composite_sync:1; | ||
160 | u8 separate_syncs:1; | ||
161 | u8 blank_to_black:1; | ||
162 | u8 video_level:2; | ||
163 | u8 digital:1; /* bits below must be zero if set */ | ||
164 | u8 width_cm; | 167 | u8 width_cm; |
165 | u8 height_cm; | 168 | u8 height_cm; |
166 | u8 gamma; | 169 | u8 gamma; |
167 | /* feature support */ | 170 | u8 features; |
168 | u8 default_gtf:1; | ||
169 | u8 preferred_timing:1; | ||
170 | u8 standard_color:1; | ||
171 | u8 display_type:2; /* 00=mono, 01=rgb, 10=non-rgb, 11=unknown */ | ||
172 | u8 pm_active_off:1; | ||
173 | u8 pm_suspend:1; | ||
174 | u8 pm_standby:1; | ||
175 | /* Color characteristics */ | 171 | /* Color characteristics */ |
176 | u8 red_green_lo; | 172 | u8 red_green_lo; |
177 | u8 black_white_lo; | 173 | u8 black_white_lo; |
@@ -195,8 +191,6 @@ struct edid { | |||
195 | u8 checksum; | 191 | u8 checksum; |
196 | } __attribute__((packed)); | 192 | } __attribute__((packed)); |
197 | 193 | ||
198 | #endif /* little endian structs */ | ||
199 | |||
200 | #define EDID_PRODUCT_ID(e) ((e)->prod_code[0] | ((e)->prod_code[1] << 8)) | 194 | #define EDID_PRODUCT_ID(e) ((e)->prod_code[0] | ((e)->prod_code[1] << 8)) |
201 | 195 | ||
202 | #endif /* __DRM_EDID_H__ */ | 196 | #endif /* __DRM_EDID_H__ */ |
diff --git a/include/drm/drm_memory_debug.h b/include/drm/drm_memory_debug.h deleted file mode 100644 index 6463271deea8..000000000000 --- a/include/drm/drm_memory_debug.h +++ /dev/null | |||
@@ -1,309 +0,0 @@ | |||
1 | /** | ||
2 | * \file drm_memory_debug.h | ||
3 | * Memory management wrappers for DRM. | ||
4 | * | ||
5 | * \author Rickard E. (Rik) Faith <faith@valinux.com> | ||
6 | * \author Gareth Hughes <gareth@valinux.com> | ||
7 | */ | ||
8 | |||
9 | /* | ||
10 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. | ||
11 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. | ||
12 | * All Rights Reserved. | ||
13 | * | ||
14 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
15 | * copy of this software and associated documentation files (the "Software"), | ||
16 | * to deal in the Software without restriction, including without limitation | ||
17 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
18 | * and/or sell copies of the Software, and to permit persons to whom the | ||
19 | * Software is furnished to do so, subject to the following conditions: | ||
20 | * | ||
21 | * The above copyright notice and this permission notice (including the next | ||
22 | * paragraph) shall be included in all copies or substantial portions of the | ||
23 | * Software. | ||
24 | * | ||
25 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
26 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
27 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
28 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
29 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
30 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
31 | * OTHER DEALINGS IN THE SOFTWARE. | ||
32 | */ | ||
33 | |||
34 | #include "drmP.h" | ||
35 | |||
36 | typedef struct drm_mem_stats { | ||
37 | const char *name; | ||
38 | int succeed_count; | ||
39 | int free_count; | ||
40 | int fail_count; | ||
41 | unsigned long bytes_allocated; | ||
42 | unsigned long bytes_freed; | ||
43 | } drm_mem_stats_t; | ||
44 | |||
45 | static DEFINE_SPINLOCK(drm_mem_lock); | ||
46 | static unsigned long drm_ram_available = 0; /* In pages */ | ||
47 | static unsigned long drm_ram_used = 0; | ||
48 | static drm_mem_stats_t drm_mem_stats[] = | ||
49 | { | ||
50 | [DRM_MEM_DMA] = {"dmabufs"}, | ||
51 | [DRM_MEM_SAREA] = {"sareas"}, | ||
52 | [DRM_MEM_DRIVER] = {"driver"}, | ||
53 | [DRM_MEM_MAGIC] = {"magic"}, | ||
54 | [DRM_MEM_IOCTLS] = {"ioctltab"}, | ||
55 | [DRM_MEM_MAPS] = {"maplist"}, | ||
56 | [DRM_MEM_VMAS] = {"vmalist"}, | ||
57 | [DRM_MEM_BUFS] = {"buflist"}, | ||
58 | [DRM_MEM_SEGS] = {"seglist"}, | ||
59 | [DRM_MEM_PAGES] = {"pagelist"}, | ||
60 | [DRM_MEM_FILES] = {"files"}, | ||
61 | [DRM_MEM_QUEUES] = {"queues"}, | ||
62 | [DRM_MEM_CMDS] = {"commands"}, | ||
63 | [DRM_MEM_MAPPINGS] = {"mappings"}, | ||
64 | [DRM_MEM_BUFLISTS] = {"buflists"}, | ||
65 | [DRM_MEM_AGPLISTS] = {"agplist"}, | ||
66 | [DRM_MEM_SGLISTS] = {"sglist"}, | ||
67 | [DRM_MEM_TOTALAGP] = {"totalagp"}, | ||
68 | [DRM_MEM_BOUNDAGP] = {"boundagp"}, | ||
69 | [DRM_MEM_CTXBITMAP] = {"ctxbitmap"}, | ||
70 | [DRM_MEM_CTXLIST] = {"ctxlist"}, | ||
71 | [DRM_MEM_STUB] = {"stub"}, | ||
72 | {NULL, 0,} /* Last entry must be null */ | ||
73 | }; | ||
74 | |||
75 | void drm_mem_init (void) { | ||
76 | drm_mem_stats_t *mem; | ||
77 | struct sysinfo si; | ||
78 | |||
79 | for (mem = drm_mem_stats; mem->name; ++mem) { | ||
80 | mem->succeed_count = 0; | ||
81 | mem->free_count = 0; | ||
82 | mem->fail_count = 0; | ||
83 | mem->bytes_allocated = 0; | ||
84 | mem->bytes_freed = 0; | ||
85 | } | ||
86 | |||
87 | si_meminfo(&si); | ||
88 | drm_ram_available = si.totalram; | ||
89 | drm_ram_used = 0; | ||
90 | } | ||
91 | |||
92 | /* drm_mem_info is called whenever a process reads /dev/drm/mem. */ | ||
93 | |||
94 | static int drm__mem_info (char *buf, char **start, off_t offset, | ||
95 | int request, int *eof, void *data) { | ||
96 | drm_mem_stats_t *pt; | ||
97 | int len = 0; | ||
98 | |||
99 | if (offset > DRM_PROC_LIMIT) { | ||
100 | *eof = 1; | ||
101 | return 0; | ||
102 | } | ||
103 | |||
104 | *eof = 0; | ||
105 | *start = &buf[offset]; | ||
106 | |||
107 | DRM_PROC_PRINT(" total counts " | ||
108 | " | outstanding \n"); | ||
109 | DRM_PROC_PRINT("type alloc freed fail bytes freed" | ||
110 | " | allocs bytes\n\n"); | ||
111 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB |\n", | ||
112 | "system", 0, 0, 0, | ||
113 | drm_ram_available << (PAGE_SHIFT - 10)); | ||
114 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB |\n", | ||
115 | "locked", 0, 0, 0, drm_ram_used >> 10); | ||
116 | DRM_PROC_PRINT("\n"); | ||
117 | for (pt = drm_mem_stats; pt->name; pt++) { | ||
118 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu %10lu | %6d %10ld\n", | ||
119 | pt->name, | ||
120 | pt->succeed_count, | ||
121 | pt->free_count, | ||
122 | pt->fail_count, | ||
123 | pt->bytes_allocated, | ||
124 | pt->bytes_freed, | ||
125 | pt->succeed_count - pt->free_count, | ||
126 | (long)pt->bytes_allocated | ||
127 | - (long)pt->bytes_freed); | ||
128 | } | ||
129 | |||
130 | if (len > request + offset) | ||
131 | return request; | ||
132 | *eof = 1; | ||
133 | return len - offset; | ||
134 | } | ||
135 | |||
136 | int drm_mem_info (char *buf, char **start, off_t offset, | ||
137 | int len, int *eof, void *data) { | ||
138 | int ret; | ||
139 | |||
140 | spin_lock(&drm_mem_lock); | ||
141 | ret = drm__mem_info (buf, start, offset, len, eof, data); | ||
142 | spin_unlock(&drm_mem_lock); | ||
143 | return ret; | ||
144 | } | ||
145 | |||
146 | void *drm_alloc (size_t size, int area) { | ||
147 | void *pt; | ||
148 | |||
149 | if (!size) { | ||
150 | DRM_MEM_ERROR(area, "Allocating 0 bytes\n"); | ||
151 | return NULL; | ||
152 | } | ||
153 | |||
154 | if (!(pt = kmalloc(size, GFP_KERNEL))) { | ||
155 | spin_lock(&drm_mem_lock); | ||
156 | ++drm_mem_stats[area].fail_count; | ||
157 | spin_unlock(&drm_mem_lock); | ||
158 | return NULL; | ||
159 | } | ||
160 | spin_lock(&drm_mem_lock); | ||
161 | ++drm_mem_stats[area].succeed_count; | ||
162 | drm_mem_stats[area].bytes_allocated += size; | ||
163 | spin_unlock(&drm_mem_lock); | ||
164 | return pt; | ||
165 | } | ||
166 | |||
167 | void *drm_calloc (size_t nmemb, size_t size, int area) { | ||
168 | void *addr; | ||
169 | |||
170 | addr = drm_alloc (nmemb * size, area); | ||
171 | if (addr != NULL) | ||
172 | memset((void *)addr, 0, size * nmemb); | ||
173 | |||
174 | return addr; | ||
175 | } | ||
176 | |||
177 | void *drm_realloc (void *oldpt, size_t oldsize, size_t size, int area) { | ||
178 | void *pt; | ||
179 | |||
180 | if (!(pt = drm_alloc (size, area))) | ||
181 | return NULL; | ||
182 | if (oldpt && oldsize) { | ||
183 | memcpy(pt, oldpt, oldsize); | ||
184 | drm_free (oldpt, oldsize, area); | ||
185 | } | ||
186 | return pt; | ||
187 | } | ||
188 | |||
189 | void drm_free (void *pt, size_t size, int area) { | ||
190 | int alloc_count; | ||
191 | int free_count; | ||
192 | |||
193 | if (!pt) | ||
194 | DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n"); | ||
195 | else | ||
196 | kfree(pt); | ||
197 | spin_lock(&drm_mem_lock); | ||
198 | drm_mem_stats[area].bytes_freed += size; | ||
199 | free_count = ++drm_mem_stats[area].free_count; | ||
200 | alloc_count = drm_mem_stats[area].succeed_count; | ||
201 | spin_unlock(&drm_mem_lock); | ||
202 | if (free_count > alloc_count) { | ||
203 | DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n", | ||
204 | free_count, alloc_count); | ||
205 | } | ||
206 | } | ||
207 | |||
208 | #if __OS_HAS_AGP | ||
209 | |||
210 | DRM_AGP_MEM *drm_alloc_agp (drm_device_t *dev, int pages, u32 type) { | ||
211 | DRM_AGP_MEM *handle; | ||
212 | |||
213 | if (!pages) { | ||
214 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, "Allocating 0 pages\n"); | ||
215 | return NULL; | ||
216 | } | ||
217 | |||
218 | if ((handle = drm_agp_allocate_memory (pages, type))) { | ||
219 | spin_lock(&drm_mem_lock); | ||
220 | ++drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count; | ||
221 | drm_mem_stats[DRM_MEM_TOTALAGP].bytes_allocated | ||
222 | += pages << PAGE_SHIFT; | ||
223 | spin_unlock(&drm_mem_lock); | ||
224 | return handle; | ||
225 | } | ||
226 | spin_lock(&drm_mem_lock); | ||
227 | ++drm_mem_stats[DRM_MEM_TOTALAGP].fail_count; | ||
228 | spin_unlock(&drm_mem_lock); | ||
229 | return NULL; | ||
230 | } | ||
231 | |||
232 | int drm_free_agp (DRM_AGP_MEM * handle, int pages) { | ||
233 | int alloc_count; | ||
234 | int free_count; | ||
235 | int retval = -EINVAL; | ||
236 | |||
237 | if (!handle) { | ||
238 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, | ||
239 | "Attempt to free NULL AGP handle\n"); | ||
240 | return retval; | ||
241 | } | ||
242 | |||
243 | if (drm_agp_free_memory (handle)) { | ||
244 | spin_lock(&drm_mem_lock); | ||
245 | free_count = ++drm_mem_stats[DRM_MEM_TOTALAGP].free_count; | ||
246 | alloc_count = drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count; | ||
247 | drm_mem_stats[DRM_MEM_TOTALAGP].bytes_freed | ||
248 | += pages << PAGE_SHIFT; | ||
249 | spin_unlock(&drm_mem_lock); | ||
250 | if (free_count > alloc_count) { | ||
251 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, | ||
252 | "Excess frees: %d frees, %d allocs\n", | ||
253 | free_count, alloc_count); | ||
254 | } | ||
255 | return 0; | ||
256 | } | ||
257 | return retval; | ||
258 | } | ||
259 | |||
260 | int drm_bind_agp (DRM_AGP_MEM * handle, unsigned int start) { | ||
261 | int retcode = -EINVAL; | ||
262 | |||
263 | if (!handle) { | ||
264 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | ||
265 | "Attempt to bind NULL AGP handle\n"); | ||
266 | return retcode; | ||
267 | } | ||
268 | |||
269 | if (!(retcode = drm_agp_bind_memory (handle, start))) { | ||
270 | spin_lock(&drm_mem_lock); | ||
271 | ++drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count; | ||
272 | drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_allocated | ||
273 | += handle->page_count << PAGE_SHIFT; | ||
274 | spin_unlock(&drm_mem_lock); | ||
275 | return retcode; | ||
276 | } | ||
277 | spin_lock(&drm_mem_lock); | ||
278 | ++drm_mem_stats[DRM_MEM_BOUNDAGP].fail_count; | ||
279 | spin_unlock(&drm_mem_lock); | ||
280 | return retcode; | ||
281 | } | ||
282 | |||
283 | int drm_unbind_agp (DRM_AGP_MEM * handle) { | ||
284 | int alloc_count; | ||
285 | int free_count; | ||
286 | int retcode = -EINVAL; | ||
287 | |||
288 | if (!handle) { | ||
289 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | ||
290 | "Attempt to unbind NULL AGP handle\n"); | ||
291 | return retcode; | ||
292 | } | ||
293 | |||
294 | if ((retcode = drm_agp_unbind_memory (handle))) | ||
295 | return retcode; | ||
296 | spin_lock(&drm_mem_lock); | ||
297 | free_count = ++drm_mem_stats[DRM_MEM_BOUNDAGP].free_count; | ||
298 | alloc_count = drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count; | ||
299 | drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_freed | ||
300 | += handle->page_count << PAGE_SHIFT; | ||
301 | spin_unlock(&drm_mem_lock); | ||
302 | if (free_count > alloc_count) { | ||
303 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | ||
304 | "Excess frees: %d frees, %d allocs\n", | ||
305 | free_count, alloc_count); | ||
306 | } | ||
307 | return retcode; | ||
308 | } | ||
309 | #endif | ||
diff --git a/include/drm/drm_mm.h b/include/drm/drm_mm.h index 5662f4278ef3..f8332073d277 100644 --- a/include/drm/drm_mm.h +++ b/include/drm/drm_mm.h | |||
@@ -59,13 +59,22 @@ struct drm_mm { | |||
59 | /* | 59 | /* |
60 | * Basic range manager support (drm_mm.c) | 60 | * Basic range manager support (drm_mm.c) |
61 | */ | 61 | */ |
62 | 62 | extern struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node, | |
63 | extern struct drm_mm_node *drm_mm_get_block(struct drm_mm_node *parent, | 63 | unsigned long size, |
64 | unsigned long size, | 64 | unsigned alignment, |
65 | unsigned alignment); | 65 | int atomic); |
66 | extern struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent, | 66 | static inline struct drm_mm_node *drm_mm_get_block(struct drm_mm_node *parent, |
67 | unsigned long size, | 67 | unsigned long size, |
68 | unsigned alignment); | 68 | unsigned alignment) |
69 | { | ||
70 | return drm_mm_get_block_generic(parent, size, alignment, 0); | ||
71 | } | ||
72 | static inline struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent, | ||
73 | unsigned long size, | ||
74 | unsigned alignment) | ||
75 | { | ||
76 | return drm_mm_get_block_generic(parent, size, alignment, 1); | ||
77 | } | ||
69 | extern void drm_mm_put_block(struct drm_mm_node *cur); | 78 | extern void drm_mm_put_block(struct drm_mm_node *cur); |
70 | extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, | 79 | extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, |
71 | unsigned long size, | 80 | unsigned long size, |
diff --git a/include/linux/Kbuild b/include/linux/Kbuild index 03f22076381f..334a3593cdfd 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild | |||
@@ -57,6 +57,7 @@ header-y += dlmconstants.h | |||
57 | header-y += dlm_device.h | 57 | header-y += dlm_device.h |
58 | header-y += dlm_netlink.h | 58 | header-y += dlm_netlink.h |
59 | header-y += dm-ioctl.h | 59 | header-y += dm-ioctl.h |
60 | header-y += dm-log-userspace.h | ||
60 | header-y += dn.h | 61 | header-y += dn.h |
61 | header-y += dqblk_xfs.h | 62 | header-y += dqblk_xfs.h |
62 | header-y += efs_fs_sb.h | 63 | header-y += efs_fs_sb.h |
diff --git a/include/linux/acpi.h b/include/linux/acpi.h index 51b4b0a5ce8c..34321cfffeab 100644 --- a/include/linux/acpi.h +++ b/include/linux/acpi.h | |||
@@ -113,9 +113,6 @@ void acpi_irq_stats_init(void); | |||
113 | extern u32 acpi_irq_handled; | 113 | extern u32 acpi_irq_handled; |
114 | extern u32 acpi_irq_not_handled; | 114 | extern u32 acpi_irq_not_handled; |
115 | 115 | ||
116 | extern struct acpi_mcfg_allocation *pci_mmcfg_config; | ||
117 | extern int pci_mmcfg_config_num; | ||
118 | |||
119 | extern int sbf_port; | 116 | extern int sbf_port; |
120 | extern unsigned long acpi_realmode_flags; | 117 | extern unsigned long acpi_realmode_flags; |
121 | 118 | ||
@@ -293,7 +290,10 @@ void __init acpi_s4_no_nvs(void); | |||
293 | OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL) | 290 | OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL) |
294 | 291 | ||
295 | extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags); | 292 | extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags); |
293 | extern void acpi_early_init(void); | ||
294 | |||
296 | #else /* CONFIG_ACPI */ | 295 | #else /* CONFIG_ACPI */ |
296 | static inline void acpi_early_init(void) { } | ||
297 | 297 | ||
298 | static inline int early_acpi_boot_init(void) | 298 | static inline int early_acpi_boot_init(void) |
299 | { | 299 | { |
diff --git a/include/linux/agp_backend.h b/include/linux/agp_backend.h index 2b8df8b420fd..76fa794fdac0 100644 --- a/include/linux/agp_backend.h +++ b/include/linux/agp_backend.h | |||
@@ -70,7 +70,7 @@ struct agp_memory { | |||
70 | struct agp_memory *next; | 70 | struct agp_memory *next; |
71 | struct agp_memory *prev; | 71 | struct agp_memory *prev; |
72 | struct agp_bridge_data *bridge; | 72 | struct agp_bridge_data *bridge; |
73 | unsigned long *memory; | 73 | struct page **pages; |
74 | size_t page_count; | 74 | size_t page_count; |
75 | int key; | 75 | int key; |
76 | int num_scratch_pages; | 76 | int num_scratch_pages; |
diff --git a/include/linux/amba/pl061.h b/include/linux/amba/pl061.h new file mode 100644 index 000000000000..b4fbd9862606 --- /dev/null +++ b/include/linux/amba/pl061.h | |||
@@ -0,0 +1,15 @@ | |||
1 | /* platform data for the PL061 GPIO driver */ | ||
2 | |||
3 | struct pl061_platform_data { | ||
4 | /* number of the first GPIO */ | ||
5 | unsigned gpio_base; | ||
6 | |||
7 | /* number of the first IRQ. | ||
8 | * If the IRQ functionality in not desired this must be set to | ||
9 | * (unsigned) -1. | ||
10 | */ | ||
11 | unsigned irq_base; | ||
12 | |||
13 | u8 directions; /* startup directions, 1: out, 0: in */ | ||
14 | u8 values; /* startup values */ | ||
15 | }; | ||
diff --git a/include/linux/ata.h b/include/linux/ata.h index 915da43edee1..9c75921f0c16 100644 --- a/include/linux/ata.h +++ b/include/linux/ata.h | |||
@@ -800,6 +800,20 @@ static inline int ata_id_is_ssd(const u16 *id) | |||
800 | return id[ATA_ID_ROT_SPEED] == 0x01; | 800 | return id[ATA_ID_ROT_SPEED] == 0x01; |
801 | } | 801 | } |
802 | 802 | ||
803 | static inline int ata_id_pio_need_iordy(const u16 *id, const u8 pio) | ||
804 | { | ||
805 | /* CF spec. r4.1 Table 22 says no IORDY on PIO5 and PIO6. */ | ||
806 | if (pio > 4 && ata_id_is_cfa(id)) | ||
807 | return 0; | ||
808 | /* For PIO3 and higher it is mandatory. */ | ||
809 | if (pio > 2) | ||
810 | return 1; | ||
811 | /* Turn it on when possible. */ | ||
812 | if (ata_id_has_iordy(id)) | ||
813 | return 1; | ||
814 | return 0; | ||
815 | } | ||
816 | |||
803 | static inline int ata_drive_40wire(const u16 *dev_id) | 817 | static inline int ata_drive_40wire(const u16 *dev_id) |
804 | { | 818 | { |
805 | if (ata_id_is_sata(dev_id)) | 819 | if (ata_id_is_sata(dev_id)) |
diff --git a/include/linux/audit.h b/include/linux/audit.h index 4fa2810b675e..3c7a358241a7 100644 --- a/include/linux/audit.h +++ b/include/linux/audit.h | |||
@@ -599,6 +599,8 @@ extern void audit_log_untrustedstring(struct audit_buffer *ab, | |||
599 | extern void audit_log_d_path(struct audit_buffer *ab, | 599 | extern void audit_log_d_path(struct audit_buffer *ab, |
600 | const char *prefix, | 600 | const char *prefix, |
601 | struct path *path); | 601 | struct path *path); |
602 | extern void audit_log_key(struct audit_buffer *ab, | ||
603 | char *key); | ||
602 | extern void audit_log_lost(const char *message); | 604 | extern void audit_log_lost(const char *message); |
603 | extern int audit_update_lsm_rules(void); | 605 | extern int audit_update_lsm_rules(void); |
604 | 606 | ||
@@ -621,6 +623,7 @@ extern int audit_enabled; | |||
621 | #define audit_log_n_untrustedstring(a,n,s) do { ; } while (0) | 623 | #define audit_log_n_untrustedstring(a,n,s) do { ; } while (0) |
622 | #define audit_log_untrustedstring(a,s) do { ; } while (0) | 624 | #define audit_log_untrustedstring(a,s) do { ; } while (0) |
623 | #define audit_log_d_path(b, p, d) do { ; } while (0) | 625 | #define audit_log_d_path(b, p, d) do { ; } while (0) |
626 | #define audit_log_key(b, k) do { ; } while (0) | ||
624 | #define audit_enabled 0 | 627 | #define audit_enabled 0 |
625 | #endif | 628 | #endif |
626 | #endif | 629 | #endif |
diff --git a/include/linux/connector.h b/include/linux/connector.h index b9966e64604e..b68d27850d51 100644 --- a/include/linux/connector.h +++ b/include/linux/connector.h | |||
@@ -41,8 +41,10 @@ | |||
41 | #define CN_IDX_BB 0x5 /* BlackBoard, from the TSP GPL sampling framework */ | 41 | #define CN_IDX_BB 0x5 /* BlackBoard, from the TSP GPL sampling framework */ |
42 | #define CN_DST_IDX 0x6 | 42 | #define CN_DST_IDX 0x6 |
43 | #define CN_DST_VAL 0x1 | 43 | #define CN_DST_VAL 0x1 |
44 | #define CN_IDX_DM 0x7 /* Device Mapper */ | ||
45 | #define CN_VAL_DM_USERSPACE_LOG 0x1 | ||
44 | 46 | ||
45 | #define CN_NETLINK_USERS 7 | 47 | #define CN_NETLINK_USERS 8 |
46 | 48 | ||
47 | /* | 49 | /* |
48 | * Maximum connector's message size. | 50 | * Maximum connector's message size. |
diff --git a/include/linux/cpu.h b/include/linux/cpu.h index 2643d848df90..4d668e05d458 100644 --- a/include/linux/cpu.h +++ b/include/linux/cpu.h | |||
@@ -69,7 +69,6 @@ static inline void unregister_cpu_notifier(struct notifier_block *nb) | |||
69 | 69 | ||
70 | int cpu_up(unsigned int cpu); | 70 | int cpu_up(unsigned int cpu); |
71 | void notify_cpu_starting(unsigned int cpu); | 71 | void notify_cpu_starting(unsigned int cpu); |
72 | extern void cpu_hotplug_init(void); | ||
73 | extern void cpu_maps_update_begin(void); | 72 | extern void cpu_maps_update_begin(void); |
74 | extern void cpu_maps_update_done(void); | 73 | extern void cpu_maps_update_done(void); |
75 | 74 | ||
@@ -84,10 +83,6 @@ static inline void unregister_cpu_notifier(struct notifier_block *nb) | |||
84 | { | 83 | { |
85 | } | 84 | } |
86 | 85 | ||
87 | static inline void cpu_hotplug_init(void) | ||
88 | { | ||
89 | } | ||
90 | |||
91 | static inline void cpu_maps_update_begin(void) | 86 | static inline void cpu_maps_update_begin(void) |
92 | { | 87 | { |
93 | } | 88 | } |
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h index 49c2362977fd..0d6310657f32 100644 --- a/include/linux/device-mapper.h +++ b/include/linux/device-mapper.h | |||
@@ -11,6 +11,7 @@ | |||
11 | #include <linux/bio.h> | 11 | #include <linux/bio.h> |
12 | #include <linux/blkdev.h> | 12 | #include <linux/blkdev.h> |
13 | 13 | ||
14 | struct dm_dev; | ||
14 | struct dm_target; | 15 | struct dm_target; |
15 | struct dm_table; | 16 | struct dm_table; |
16 | struct mapped_device; | 17 | struct mapped_device; |
@@ -21,6 +22,7 @@ typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t; | |||
21 | union map_info { | 22 | union map_info { |
22 | void *ptr; | 23 | void *ptr; |
23 | unsigned long long ll; | 24 | unsigned long long ll; |
25 | unsigned flush_request; | ||
24 | }; | 26 | }; |
25 | 27 | ||
26 | /* | 28 | /* |
@@ -80,6 +82,15 @@ typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd, | |||
80 | typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm, | 82 | typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm, |
81 | struct bio_vec *biovec, int max_size); | 83 | struct bio_vec *biovec, int max_size); |
82 | 84 | ||
85 | typedef int (*iterate_devices_callout_fn) (struct dm_target *ti, | ||
86 | struct dm_dev *dev, | ||
87 | sector_t physical_start, | ||
88 | void *data); | ||
89 | |||
90 | typedef int (*dm_iterate_devices_fn) (struct dm_target *ti, | ||
91 | iterate_devices_callout_fn fn, | ||
92 | void *data); | ||
93 | |||
83 | /* | 94 | /* |
84 | * Returns: | 95 | * Returns: |
85 | * 0: The target can handle the next I/O immediately. | 96 | * 0: The target can handle the next I/O immediately. |
@@ -92,7 +103,8 @@ void dm_error(const char *message); | |||
92 | /* | 103 | /* |
93 | * Combine device limits. | 104 | * Combine device limits. |
94 | */ | 105 | */ |
95 | void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev); | 106 | int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev, |
107 | sector_t start, void *data); | ||
96 | 108 | ||
97 | struct dm_dev { | 109 | struct dm_dev { |
98 | struct block_device *bdev; | 110 | struct block_device *bdev; |
@@ -138,23 +150,12 @@ struct target_type { | |||
138 | dm_ioctl_fn ioctl; | 150 | dm_ioctl_fn ioctl; |
139 | dm_merge_fn merge; | 151 | dm_merge_fn merge; |
140 | dm_busy_fn busy; | 152 | dm_busy_fn busy; |
153 | dm_iterate_devices_fn iterate_devices; | ||
141 | 154 | ||
142 | /* For internal device-mapper use. */ | 155 | /* For internal device-mapper use. */ |
143 | struct list_head list; | 156 | struct list_head list; |
144 | }; | 157 | }; |
145 | 158 | ||
146 | struct io_restrictions { | ||
147 | unsigned long bounce_pfn; | ||
148 | unsigned long seg_boundary_mask; | ||
149 | unsigned max_hw_sectors; | ||
150 | unsigned max_sectors; | ||
151 | unsigned max_segment_size; | ||
152 | unsigned short logical_block_size; | ||
153 | unsigned short max_hw_segments; | ||
154 | unsigned short max_phys_segments; | ||
155 | unsigned char no_cluster; /* inverted so that 0 is default */ | ||
156 | }; | ||
157 | |||
158 | struct dm_target { | 159 | struct dm_target { |
159 | struct dm_table *table; | 160 | struct dm_table *table; |
160 | struct target_type *type; | 161 | struct target_type *type; |
@@ -163,15 +164,18 @@ struct dm_target { | |||
163 | sector_t begin; | 164 | sector_t begin; |
164 | sector_t len; | 165 | sector_t len; |
165 | 166 | ||
166 | /* FIXME: turn this into a mask, and merge with io_restrictions */ | ||
167 | /* Always a power of 2 */ | 167 | /* Always a power of 2 */ |
168 | sector_t split_io; | 168 | sector_t split_io; |
169 | 169 | ||
170 | /* | 170 | /* |
171 | * These are automatically filled in by | 171 | * A number of zero-length barrier requests that will be submitted |
172 | * dm_table_get_device. | 172 | * to the target for the purpose of flushing cache. |
173 | * | ||
174 | * The request number will be placed in union map_info->flush_request. | ||
175 | * It is a responsibility of the target driver to remap these requests | ||
176 | * to the real underlying devices. | ||
173 | */ | 177 | */ |
174 | struct io_restrictions limits; | 178 | unsigned num_flush_requests; |
175 | 179 | ||
176 | /* target specific data */ | 180 | /* target specific data */ |
177 | void *private; | 181 | void *private; |
@@ -230,6 +234,7 @@ struct gendisk *dm_disk(struct mapped_device *md); | |||
230 | int dm_suspended(struct mapped_device *md); | 234 | int dm_suspended(struct mapped_device *md); |
231 | int dm_noflush_suspending(struct dm_target *ti); | 235 | int dm_noflush_suspending(struct dm_target *ti); |
232 | union map_info *dm_get_mapinfo(struct bio *bio); | 236 | union map_info *dm_get_mapinfo(struct bio *bio); |
237 | union map_info *dm_get_rq_mapinfo(struct request *rq); | ||
233 | 238 | ||
234 | /* | 239 | /* |
235 | * Geometry functions. | 240 | * Geometry functions. |
@@ -392,4 +397,12 @@ static inline unsigned long to_bytes(sector_t n) | |||
392 | return (n << SECTOR_SHIFT); | 397 | return (n << SECTOR_SHIFT); |
393 | } | 398 | } |
394 | 399 | ||
400 | /*----------------------------------------------------------------- | ||
401 | * Helper for block layer and dm core operations | ||
402 | *---------------------------------------------------------------*/ | ||
403 | void dm_dispatch_request(struct request *rq); | ||
404 | void dm_requeue_unmapped_request(struct request *rq); | ||
405 | void dm_kill_unmapped_request(struct request *rq, int error); | ||
406 | int dm_underlying_device_busy(struct request_queue *q); | ||
407 | |||
395 | #endif /* _LINUX_DEVICE_MAPPER_H */ | 408 | #endif /* _LINUX_DEVICE_MAPPER_H */ |
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h index 48e44ee2b466..2ab84c83c31a 100644 --- a/include/linux/dm-ioctl.h +++ b/include/linux/dm-ioctl.h | |||
@@ -123,6 +123,16 @@ struct dm_ioctl { | |||
123 | __u32 target_count; /* in/out */ | 123 | __u32 target_count; /* in/out */ |
124 | __s32 open_count; /* out */ | 124 | __s32 open_count; /* out */ |
125 | __u32 flags; /* in/out */ | 125 | __u32 flags; /* in/out */ |
126 | |||
127 | /* | ||
128 | * event_nr holds either the event number (input and output) or the | ||
129 | * udev cookie value (input only). | ||
130 | * The DM_DEV_WAIT ioctl takes an event number as input. | ||
131 | * The DM_SUSPEND, DM_DEV_REMOVE and DM_DEV_RENAME ioctls | ||
132 | * use the field as a cookie to return in the DM_COOKIE | ||
133 | * variable with the uevents they issue. | ||
134 | * For output, the ioctls return the event number, not the cookie. | ||
135 | */ | ||
126 | __u32 event_nr; /* in/out */ | 136 | __u32 event_nr; /* in/out */ |
127 | __u32 padding; | 137 | __u32 padding; |
128 | 138 | ||
@@ -256,9 +266,9 @@ enum { | |||
256 | #define DM_DEV_SET_GEOMETRY _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl) | 266 | #define DM_DEV_SET_GEOMETRY _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl) |
257 | 267 | ||
258 | #define DM_VERSION_MAJOR 4 | 268 | #define DM_VERSION_MAJOR 4 |
259 | #define DM_VERSION_MINOR 14 | 269 | #define DM_VERSION_MINOR 15 |
260 | #define DM_VERSION_PATCHLEVEL 0 | 270 | #define DM_VERSION_PATCHLEVEL 0 |
261 | #define DM_VERSION_EXTRA "-ioctl (2008-04-23)" | 271 | #define DM_VERSION_EXTRA "-ioctl (2009-04-01)" |
262 | 272 | ||
263 | /* Status bits */ | 273 | /* Status bits */ |
264 | #define DM_READONLY_FLAG (1 << 0) /* In/Out */ | 274 | #define DM_READONLY_FLAG (1 << 0) /* In/Out */ |
diff --git a/include/linux/dm-log-userspace.h b/include/linux/dm-log-userspace.h new file mode 100644 index 000000000000..642e3017b51f --- /dev/null +++ b/include/linux/dm-log-userspace.h | |||
@@ -0,0 +1,386 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2006-2009 Red Hat, Inc. | ||
3 | * | ||
4 | * This file is released under the LGPL. | ||
5 | */ | ||
6 | |||
7 | #ifndef __DM_LOG_USERSPACE_H__ | ||
8 | #define __DM_LOG_USERSPACE_H__ | ||
9 | |||
10 | #include <linux/dm-ioctl.h> /* For DM_UUID_LEN */ | ||
11 | |||
12 | /* | ||
13 | * The device-mapper userspace log module consists of a kernel component and | ||
14 | * a user-space component. The kernel component implements the API defined | ||
15 | * in dm-dirty-log.h. Its purpose is simply to pass the parameters and | ||
16 | * return values of those API functions between kernel and user-space. | ||
17 | * | ||
18 | * Below are defined the 'request_types' - DM_ULOG_CTR, DM_ULOG_DTR, etc. | ||
19 | * These request types represent the different functions in the device-mapper | ||
20 | * dirty log API. Each of these is described in more detail below. | ||
21 | * | ||
22 | * The user-space program must listen for requests from the kernel (representing | ||
23 | * the various API functions) and process them. | ||
24 | * | ||
25 | * User-space begins by setting up the communication link (error checking | ||
26 | * removed for clarity): | ||
27 | * fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR); | ||
28 | * addr.nl_family = AF_NETLINK; | ||
29 | * addr.nl_groups = CN_IDX_DM; | ||
30 | * addr.nl_pid = 0; | ||
31 | * r = bind(fd, (struct sockaddr *) &addr, sizeof(addr)); | ||
32 | * opt = addr.nl_groups; | ||
33 | * setsockopt(fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &opt, sizeof(opt)); | ||
34 | * | ||
35 | * User-space will then wait to receive requests form the kernel, which it | ||
36 | * will process as described below. The requests are received in the form, | ||
37 | * ((struct dm_ulog_request) + (additional data)). Depending on the request | ||
38 | * type, there may or may not be 'additional data'. In the descriptions below, | ||
39 | * you will see 'Payload-to-userspace' and 'Payload-to-kernel'. The | ||
40 | * 'Payload-to-userspace' is what the kernel sends in 'additional data' as | ||
41 | * necessary parameters to complete the request. The 'Payload-to-kernel' is | ||
42 | * the 'additional data' returned to the kernel that contains the necessary | ||
43 | * results of the request. The 'data_size' field in the dm_ulog_request | ||
44 | * structure denotes the availability and amount of payload data. | ||
45 | */ | ||
46 | |||
47 | /* | ||
48 | * DM_ULOG_CTR corresponds to (found in dm-dirty-log.h): | ||
49 | * int (*ctr)(struct dm_dirty_log *log, struct dm_target *ti, | ||
50 | * unsigned argc, char **argv); | ||
51 | * | ||
52 | * Payload-to-userspace: | ||
53 | * A single string containing all the argv arguments separated by ' 's | ||
54 | * Payload-to-kernel: | ||
55 | * None. ('data_size' in the dm_ulog_request struct should be 0.) | ||
56 | * | ||
57 | * The UUID contained in the dm_ulog_request structure is the reference that | ||
58 | * will be used by all request types to a specific log. The constructor must | ||
59 | * record this assotiation with instance created. | ||
60 | * | ||
61 | * When the request has been processed, user-space must return the | ||
62 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
63 | * 'data_size' appropriately. | ||
64 | */ | ||
65 | #define DM_ULOG_CTR 1 | ||
66 | |||
67 | /* | ||
68 | * DM_ULOG_DTR corresponds to (found in dm-dirty-log.h): | ||
69 | * void (*dtr)(struct dm_dirty_log *log); | ||
70 | * | ||
71 | * Payload-to-userspace: | ||
72 | * A single string containing all the argv arguments separated by ' 's | ||
73 | * Payload-to-kernel: | ||
74 | * None. ('data_size' in the dm_ulog_request struct should be 0.) | ||
75 | * | ||
76 | * The UUID contained in the dm_ulog_request structure is all that is | ||
77 | * necessary to identify the log instance being destroyed. There is no | ||
78 | * payload data. | ||
79 | * | ||
80 | * When the request has been processed, user-space must return the | ||
81 | * dm_ulog_request to the kernel - setting the 'error' field and clearing | ||
82 | * 'data_size' appropriately. | ||
83 | */ | ||
84 | #define DM_ULOG_DTR 2 | ||
85 | |||
86 | /* | ||
87 | * DM_ULOG_PRESUSPEND corresponds to (found in dm-dirty-log.h): | ||
88 | * int (*presuspend)(struct dm_dirty_log *log); | ||
89 | * | ||
90 | * Payload-to-userspace: | ||
91 | * None. | ||
92 | * Payload-to-kernel: | ||
93 | * None. | ||
94 | * | ||
95 | * The UUID contained in the dm_ulog_request structure is all that is | ||
96 | * necessary to identify the log instance being presuspended. There is no | ||
97 | * payload data. | ||
98 | * | ||
99 | * When the request has been processed, user-space must return the | ||
100 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
101 | * 'data_size' appropriately. | ||
102 | */ | ||
103 | #define DM_ULOG_PRESUSPEND 3 | ||
104 | |||
105 | /* | ||
106 | * DM_ULOG_POSTSUSPEND corresponds to (found in dm-dirty-log.h): | ||
107 | * int (*postsuspend)(struct dm_dirty_log *log); | ||
108 | * | ||
109 | * Payload-to-userspace: | ||
110 | * None. | ||
111 | * Payload-to-kernel: | ||
112 | * None. | ||
113 | * | ||
114 | * The UUID contained in the dm_ulog_request structure is all that is | ||
115 | * necessary to identify the log instance being postsuspended. There is no | ||
116 | * payload data. | ||
117 | * | ||
118 | * When the request has been processed, user-space must return the | ||
119 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
120 | * 'data_size' appropriately. | ||
121 | */ | ||
122 | #define DM_ULOG_POSTSUSPEND 4 | ||
123 | |||
124 | /* | ||
125 | * DM_ULOG_RESUME corresponds to (found in dm-dirty-log.h): | ||
126 | * int (*resume)(struct dm_dirty_log *log); | ||
127 | * | ||
128 | * Payload-to-userspace: | ||
129 | * None. | ||
130 | * Payload-to-kernel: | ||
131 | * None. | ||
132 | * | ||
133 | * The UUID contained in the dm_ulog_request structure is all that is | ||
134 | * necessary to identify the log instance being resumed. There is no | ||
135 | * payload data. | ||
136 | * | ||
137 | * When the request has been processed, user-space must return the | ||
138 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
139 | * 'data_size' appropriately. | ||
140 | */ | ||
141 | #define DM_ULOG_RESUME 5 | ||
142 | |||
143 | /* | ||
144 | * DM_ULOG_GET_REGION_SIZE corresponds to (found in dm-dirty-log.h): | ||
145 | * uint32_t (*get_region_size)(struct dm_dirty_log *log); | ||
146 | * | ||
147 | * Payload-to-userspace: | ||
148 | * None. | ||
149 | * Payload-to-kernel: | ||
150 | * uint64_t - contains the region size | ||
151 | * | ||
152 | * The region size is something that was determined at constructor time. | ||
153 | * It is returned in the payload area and 'data_size' is set to | ||
154 | * reflect this. | ||
155 | * | ||
156 | * When the request has been processed, user-space must return the | ||
157 | * dm_ulog_request to the kernel - setting the 'error' field appropriately. | ||
158 | */ | ||
159 | #define DM_ULOG_GET_REGION_SIZE 6 | ||
160 | |||
161 | /* | ||
162 | * DM_ULOG_IS_CLEAN corresponds to (found in dm-dirty-log.h): | ||
163 | * int (*is_clean)(struct dm_dirty_log *log, region_t region); | ||
164 | * | ||
165 | * Payload-to-userspace: | ||
166 | * uint64_t - the region to get clean status on | ||
167 | * Payload-to-kernel: | ||
168 | * int64_t - 1 if clean, 0 otherwise | ||
169 | * | ||
170 | * Payload is sizeof(uint64_t) and contains the region for which the clean | ||
171 | * status is being made. | ||
172 | * | ||
173 | * When the request has been processed, user-space must return the | ||
174 | * dm_ulog_request to the kernel - filling the payload with 0 (not clean) or | ||
175 | * 1 (clean), setting 'data_size' and 'error' appropriately. | ||
176 | */ | ||
177 | #define DM_ULOG_IS_CLEAN 7 | ||
178 | |||
179 | /* | ||
180 | * DM_ULOG_IN_SYNC corresponds to (found in dm-dirty-log.h): | ||
181 | * int (*in_sync)(struct dm_dirty_log *log, region_t region, | ||
182 | * int can_block); | ||
183 | * | ||
184 | * Payload-to-userspace: | ||
185 | * uint64_t - the region to get sync status on | ||
186 | * Payload-to-kernel: | ||
187 | * int64_t - 1 if in-sync, 0 otherwise | ||
188 | * | ||
189 | * Exactly the same as 'is_clean' above, except this time asking "has the | ||
190 | * region been recovered?" vs. "is the region not being modified?" | ||
191 | */ | ||
192 | #define DM_ULOG_IN_SYNC 8 | ||
193 | |||
194 | /* | ||
195 | * DM_ULOG_FLUSH corresponds to (found in dm-dirty-log.h): | ||
196 | * int (*flush)(struct dm_dirty_log *log); | ||
197 | * | ||
198 | * Payload-to-userspace: | ||
199 | * None. | ||
200 | * Payload-to-kernel: | ||
201 | * None. | ||
202 | * | ||
203 | * No incoming or outgoing payload. Simply flush log state to disk. | ||
204 | * | ||
205 | * When the request has been processed, user-space must return the | ||
206 | * dm_ulog_request to the kernel - setting the 'error' field and clearing | ||
207 | * 'data_size' appropriately. | ||
208 | */ | ||
209 | #define DM_ULOG_FLUSH 9 | ||
210 | |||
211 | /* | ||
212 | * DM_ULOG_MARK_REGION corresponds to (found in dm-dirty-log.h): | ||
213 | * void (*mark_region)(struct dm_dirty_log *log, region_t region); | ||
214 | * | ||
215 | * Payload-to-userspace: | ||
216 | * uint64_t [] - region(s) to mark | ||
217 | * Payload-to-kernel: | ||
218 | * None. | ||
219 | * | ||
220 | * Incoming payload contains the one or more regions to mark dirty. | ||
221 | * The number of regions contained in the payload can be determined from | ||
222 | * 'data_size/sizeof(uint64_t)'. | ||
223 | * | ||
224 | * When the request has been processed, user-space must return the | ||
225 | * dm_ulog_request to the kernel - setting the 'error' field and clearing | ||
226 | * 'data_size' appropriately. | ||
227 | */ | ||
228 | #define DM_ULOG_MARK_REGION 10 | ||
229 | |||
230 | /* | ||
231 | * DM_ULOG_CLEAR_REGION corresponds to (found in dm-dirty-log.h): | ||
232 | * void (*clear_region)(struct dm_dirty_log *log, region_t region); | ||
233 | * | ||
234 | * Payload-to-userspace: | ||
235 | * uint64_t [] - region(s) to clear | ||
236 | * Payload-to-kernel: | ||
237 | * None. | ||
238 | * | ||
239 | * Incoming payload contains the one or more regions to mark clean. | ||
240 | * The number of regions contained in the payload can be determined from | ||
241 | * 'data_size/sizeof(uint64_t)'. | ||
242 | * | ||
243 | * When the request has been processed, user-space must return the | ||
244 | * dm_ulog_request to the kernel - setting the 'error' field and clearing | ||
245 | * 'data_size' appropriately. | ||
246 | */ | ||
247 | #define DM_ULOG_CLEAR_REGION 11 | ||
248 | |||
249 | /* | ||
250 | * DM_ULOG_GET_RESYNC_WORK corresponds to (found in dm-dirty-log.h): | ||
251 | * int (*get_resync_work)(struct dm_dirty_log *log, region_t *region); | ||
252 | * | ||
253 | * Payload-to-userspace: | ||
254 | * None. | ||
255 | * Payload-to-kernel: | ||
256 | * { | ||
257 | * int64_t i; -- 1 if recovery necessary, 0 otherwise | ||
258 | * uint64_t r; -- The region to recover if i=1 | ||
259 | * } | ||
260 | * 'data_size' should be set appropriately. | ||
261 | * | ||
262 | * When the request has been processed, user-space must return the | ||
263 | * dm_ulog_request to the kernel - setting the 'error' field appropriately. | ||
264 | */ | ||
265 | #define DM_ULOG_GET_RESYNC_WORK 12 | ||
266 | |||
267 | /* | ||
268 | * DM_ULOG_SET_REGION_SYNC corresponds to (found in dm-dirty-log.h): | ||
269 | * void (*set_region_sync)(struct dm_dirty_log *log, | ||
270 | * region_t region, int in_sync); | ||
271 | * | ||
272 | * Payload-to-userspace: | ||
273 | * { | ||
274 | * uint64_t - region to set sync state on | ||
275 | * int64_t - 0 if not-in-sync, 1 if in-sync | ||
276 | * } | ||
277 | * Payload-to-kernel: | ||
278 | * None. | ||
279 | * | ||
280 | * When the request has been processed, user-space must return the | ||
281 | * dm_ulog_request to the kernel - setting the 'error' field and clearing | ||
282 | * 'data_size' appropriately. | ||
283 | */ | ||
284 | #define DM_ULOG_SET_REGION_SYNC 13 | ||
285 | |||
286 | /* | ||
287 | * DM_ULOG_GET_SYNC_COUNT corresponds to (found in dm-dirty-log.h): | ||
288 | * region_t (*get_sync_count)(struct dm_dirty_log *log); | ||
289 | * | ||
290 | * Payload-to-userspace: | ||
291 | * None. | ||
292 | * Payload-to-kernel: | ||
293 | * uint64_t - the number of in-sync regions | ||
294 | * | ||
295 | * No incoming payload. Kernel-bound payload contains the number of | ||
296 | * regions that are in-sync (in a size_t). | ||
297 | * | ||
298 | * When the request has been processed, user-space must return the | ||
299 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
300 | * 'data_size' appropriately. | ||
301 | */ | ||
302 | #define DM_ULOG_GET_SYNC_COUNT 14 | ||
303 | |||
304 | /* | ||
305 | * DM_ULOG_STATUS_INFO corresponds to (found in dm-dirty-log.h): | ||
306 | * int (*status)(struct dm_dirty_log *log, STATUSTYPE_INFO, | ||
307 | * char *result, unsigned maxlen); | ||
308 | * | ||
309 | * Payload-to-userspace: | ||
310 | * None. | ||
311 | * Payload-to-kernel: | ||
312 | * Character string containing STATUSTYPE_INFO | ||
313 | * | ||
314 | * When the request has been processed, user-space must return the | ||
315 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
316 | * 'data_size' appropriately. | ||
317 | */ | ||
318 | #define DM_ULOG_STATUS_INFO 15 | ||
319 | |||
320 | /* | ||
321 | * DM_ULOG_STATUS_TABLE corresponds to (found in dm-dirty-log.h): | ||
322 | * int (*status)(struct dm_dirty_log *log, STATUSTYPE_TABLE, | ||
323 | * char *result, unsigned maxlen); | ||
324 | * | ||
325 | * Payload-to-userspace: | ||
326 | * None. | ||
327 | * Payload-to-kernel: | ||
328 | * Character string containing STATUSTYPE_TABLE | ||
329 | * | ||
330 | * When the request has been processed, user-space must return the | ||
331 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
332 | * 'data_size' appropriately. | ||
333 | */ | ||
334 | #define DM_ULOG_STATUS_TABLE 16 | ||
335 | |||
336 | /* | ||
337 | * DM_ULOG_IS_REMOTE_RECOVERING corresponds to (found in dm-dirty-log.h): | ||
338 | * int (*is_remote_recovering)(struct dm_dirty_log *log, region_t region); | ||
339 | * | ||
340 | * Payload-to-userspace: | ||
341 | * uint64_t - region to determine recovery status on | ||
342 | * Payload-to-kernel: | ||
343 | * { | ||
344 | * int64_t is_recovering; -- 0 if no, 1 if yes | ||
345 | * uint64_t in_sync_hint; -- lowest region still needing resync | ||
346 | * } | ||
347 | * | ||
348 | * When the request has been processed, user-space must return the | ||
349 | * dm_ulog_request to the kernel - setting the 'error' field and | ||
350 | * 'data_size' appropriately. | ||
351 | */ | ||
352 | #define DM_ULOG_IS_REMOTE_RECOVERING 17 | ||
353 | |||
354 | /* | ||
355 | * (DM_ULOG_REQUEST_MASK & request_type) to get the request type | ||
356 | * | ||
357 | * Payload-to-userspace: | ||
358 | * A single string containing all the argv arguments separated by ' 's | ||
359 | * Payload-to-kernel: | ||
360 | * None. ('data_size' in the dm_ulog_request struct should be 0.) | ||
361 | * | ||
362 | * We are reserving 8 bits of the 32-bit 'request_type' field for the | ||
363 | * various request types above. The remaining 24-bits are currently | ||
364 | * set to zero and are reserved for future use and compatibility concerns. | ||
365 | * | ||
366 | * User-space should always use DM_ULOG_REQUEST_TYPE to aquire the | ||
367 | * request type from the 'request_type' field to maintain forward compatibility. | ||
368 | */ | ||
369 | #define DM_ULOG_REQUEST_MASK 0xFF | ||
370 | #define DM_ULOG_REQUEST_TYPE(request_type) \ | ||
371 | (DM_ULOG_REQUEST_MASK & (request_type)) | ||
372 | |||
373 | struct dm_ulog_request { | ||
374 | char uuid[DM_UUID_LEN]; /* Ties a request to a specific mirror log */ | ||
375 | char padding[7]; /* Padding because DM_UUID_LEN = 129 */ | ||
376 | |||
377 | int32_t error; /* Used to report back processing errors */ | ||
378 | |||
379 | uint32_t seq; /* Sequence number for request */ | ||
380 | uint32_t request_type; /* DM_ULOG_* defined above */ | ||
381 | uint32_t data_size; /* How much data (not including this struct) */ | ||
382 | |||
383 | char data[0]; | ||
384 | }; | ||
385 | |||
386 | #endif /* __DM_LOG_USERSPACE_H__ */ | ||
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h index 8083b6a36a38..07dfd460d286 100644 --- a/include/linux/dma-mapping.h +++ b/include/linux/dma-mapping.h | |||
@@ -63,24 +63,26 @@ struct dma_map_ops { | |||
63 | 63 | ||
64 | #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) | 64 | #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) |
65 | 65 | ||
66 | typedef u64 DMA_nnBIT_MASK __deprecated; | ||
67 | |||
66 | /* | 68 | /* |
67 | * NOTE: do not use the below macros in new code and do not add new definitions | 69 | * NOTE: do not use the below macros in new code and do not add new definitions |
68 | * here. | 70 | * here. |
69 | * | 71 | * |
70 | * Instead, just open-code DMA_BIT_MASK(n) within your driver | 72 | * Instead, just open-code DMA_BIT_MASK(n) within your driver |
71 | */ | 73 | */ |
72 | #define DMA_64BIT_MASK DMA_BIT_MASK(64) | 74 | #define DMA_64BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(64) |
73 | #define DMA_48BIT_MASK DMA_BIT_MASK(48) | 75 | #define DMA_48BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(48) |
74 | #define DMA_47BIT_MASK DMA_BIT_MASK(47) | 76 | #define DMA_47BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(47) |
75 | #define DMA_40BIT_MASK DMA_BIT_MASK(40) | 77 | #define DMA_40BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(40) |
76 | #define DMA_39BIT_MASK DMA_BIT_MASK(39) | 78 | #define DMA_39BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(39) |
77 | #define DMA_35BIT_MASK DMA_BIT_MASK(35) | 79 | #define DMA_35BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(35) |
78 | #define DMA_32BIT_MASK DMA_BIT_MASK(32) | 80 | #define DMA_32BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(32) |
79 | #define DMA_31BIT_MASK DMA_BIT_MASK(31) | 81 | #define DMA_31BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(31) |
80 | #define DMA_30BIT_MASK DMA_BIT_MASK(30) | 82 | #define DMA_30BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(30) |
81 | #define DMA_29BIT_MASK DMA_BIT_MASK(29) | 83 | #define DMA_29BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(29) |
82 | #define DMA_28BIT_MASK DMA_BIT_MASK(28) | 84 | #define DMA_28BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(28) |
83 | #define DMA_24BIT_MASK DMA_BIT_MASK(24) | 85 | #define DMA_24BIT_MASK (DMA_nnBIT_MASK)DMA_BIT_MASK(24) |
84 | 86 | ||
85 | #define DMA_MASK_NONE 0x0ULL | 87 | #define DMA_MASK_NONE 0x0ULL |
86 | 88 | ||
@@ -107,9 +109,20 @@ static inline int is_buffer_dma_capable(u64 mask, dma_addr_t addr, size_t size) | |||
107 | #include <asm-generic/dma-mapping-broken.h> | 109 | #include <asm-generic/dma-mapping-broken.h> |
108 | #endif | 110 | #endif |
109 | 111 | ||
110 | /* Backwards compat, remove in 2.7.x */ | 112 | /* for backwards compatibility, removed soon */ |
111 | #define dma_sync_single dma_sync_single_for_cpu | 113 | static inline void __deprecated dma_sync_single(struct device *dev, |
112 | #define dma_sync_sg dma_sync_sg_for_cpu | 114 | dma_addr_t addr, size_t size, |
115 | enum dma_data_direction dir) | ||
116 | { | ||
117 | dma_sync_single_for_cpu(dev, addr, size, dir); | ||
118 | } | ||
119 | |||
120 | static inline void __deprecated dma_sync_sg(struct device *dev, | ||
121 | struct scatterlist *sg, int nelems, | ||
122 | enum dma_data_direction dir) | ||
123 | { | ||
124 | dma_sync_sg_for_cpu(dev, sg, nelems, dir); | ||
125 | } | ||
113 | 126 | ||
114 | static inline u64 dma_get_mask(struct device *dev) | 127 | static inline u64 dma_get_mask(struct device *dev) |
115 | { | 128 | { |
diff --git a/include/linux/dma_remapping.h b/include/linux/dma_remapping.h index 1a455f1f86d7..5619f8522738 100644 --- a/include/linux/dma_remapping.h +++ b/include/linux/dma_remapping.h | |||
@@ -13,6 +13,10 @@ | |||
13 | #define DMA_PTE_WRITE (2) | 13 | #define DMA_PTE_WRITE (2) |
14 | #define DMA_PTE_SNP (1 << 11) | 14 | #define DMA_PTE_SNP (1 << 11) |
15 | 15 | ||
16 | #define CONTEXT_TT_MULTI_LEVEL 0 | ||
17 | #define CONTEXT_TT_DEV_IOTLB 1 | ||
18 | #define CONTEXT_TT_PASS_THROUGH 2 | ||
19 | |||
16 | struct intel_iommu; | 20 | struct intel_iommu; |
17 | struct dmar_domain; | 21 | struct dmar_domain; |
18 | struct root_entry; | 22 | struct root_entry; |
@@ -21,11 +25,16 @@ extern void free_dmar_iommu(struct intel_iommu *iommu); | |||
21 | 25 | ||
22 | #ifdef CONFIG_DMAR | 26 | #ifdef CONFIG_DMAR |
23 | extern int iommu_calculate_agaw(struct intel_iommu *iommu); | 27 | extern int iommu_calculate_agaw(struct intel_iommu *iommu); |
28 | extern int iommu_calculate_max_sagaw(struct intel_iommu *iommu); | ||
24 | #else | 29 | #else |
25 | static inline int iommu_calculate_agaw(struct intel_iommu *iommu) | 30 | static inline int iommu_calculate_agaw(struct intel_iommu *iommu) |
26 | { | 31 | { |
27 | return 0; | 32 | return 0; |
28 | } | 33 | } |
34 | static inline int iommu_calculate_max_sagaw(struct intel_iommu *iommu) | ||
35 | { | ||
36 | return 0; | ||
37 | } | ||
29 | #endif | 38 | #endif |
30 | 39 | ||
31 | extern int dmar_disabled; | 40 | extern int dmar_disabled; |
diff --git a/include/linux/dmar.h b/include/linux/dmar.h index 10ff5c498824..4a2b162c256a 100644 --- a/include/linux/dmar.h +++ b/include/linux/dmar.h | |||
@@ -126,6 +126,8 @@ extern int free_irte(int irq); | |||
126 | extern int irq_remapped(int irq); | 126 | extern int irq_remapped(int irq); |
127 | extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev); | 127 | extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev); |
128 | extern struct intel_iommu *map_ioapic_to_ir(int apic); | 128 | extern struct intel_iommu *map_ioapic_to_ir(int apic); |
129 | extern int set_ioapic_sid(struct irte *irte, int apic); | ||
130 | extern int set_msi_sid(struct irte *irte, struct pci_dev *dev); | ||
129 | #else | 131 | #else |
130 | static inline int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | 132 | static inline int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) |
131 | { | 133 | { |
@@ -156,6 +158,15 @@ static inline struct intel_iommu *map_ioapic_to_ir(int apic) | |||
156 | { | 158 | { |
157 | return NULL; | 159 | return NULL; |
158 | } | 160 | } |
161 | static inline int set_ioapic_sid(struct irte *irte, int apic) | ||
162 | { | ||
163 | return 0; | ||
164 | } | ||
165 | static inline int set_msi_sid(struct irte *irte, struct pci_dev *dev) | ||
166 | { | ||
167 | return 0; | ||
168 | } | ||
169 | |||
159 | #define irq_remapped(irq) (0) | 170 | #define irq_remapped(irq) (0) |
160 | #define enable_intr_remapping(mode) (-1) | 171 | #define enable_intr_remapping(mode) (-1) |
161 | #define disable_intr_remapping() (0) | 172 | #define disable_intr_remapping() (0) |
@@ -188,6 +199,15 @@ struct dmar_rmrr_unit { | |||
188 | 199 | ||
189 | #define for_each_rmrr_units(rmrr) \ | 200 | #define for_each_rmrr_units(rmrr) \ |
190 | list_for_each_entry(rmrr, &dmar_rmrr_units, list) | 201 | list_for_each_entry(rmrr, &dmar_rmrr_units, list) |
202 | |||
203 | struct dmar_atsr_unit { | ||
204 | struct list_head list; /* list of ATSR units */ | ||
205 | struct acpi_dmar_header *hdr; /* ACPI header */ | ||
206 | struct pci_dev **devices; /* target devices */ | ||
207 | int devices_cnt; /* target device count */ | ||
208 | u8 include_all:1; /* include all ports */ | ||
209 | }; | ||
210 | |||
191 | /* Intel DMAR initialization functions */ | 211 | /* Intel DMAR initialization functions */ |
192 | extern int intel_iommu_init(void); | 212 | extern int intel_iommu_init(void); |
193 | #else | 213 | #else |
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h index 7894dd0f3b77..ca1bfe90004f 100644 --- a/include/linux/ext3_fs_i.h +++ b/include/linux/ext3_fs_i.h | |||
@@ -103,10 +103,6 @@ struct ext3_inode_info { | |||
103 | */ | 103 | */ |
104 | struct rw_semaphore xattr_sem; | 104 | struct rw_semaphore xattr_sem; |
105 | #endif | 105 | #endif |
106 | #ifdef CONFIG_EXT3_FS_POSIX_ACL | ||
107 | struct posix_acl *i_acl; | ||
108 | struct posix_acl *i_default_acl; | ||
109 | #endif | ||
110 | 106 | ||
111 | struct list_head i_orphan; /* unlinked but open inodes */ | 107 | struct list_head i_orphan; /* unlinked but open inodes */ |
112 | 108 | ||
diff --git a/include/linux/falloc.h b/include/linux/falloc.h index 8e912ab6a072..3c155107d61f 100644 --- a/include/linux/falloc.h +++ b/include/linux/falloc.h | |||
@@ -3,4 +3,25 @@ | |||
3 | 3 | ||
4 | #define FALLOC_FL_KEEP_SIZE 0x01 /* default is extend size */ | 4 | #define FALLOC_FL_KEEP_SIZE 0x01 /* default is extend size */ |
5 | 5 | ||
6 | #ifdef __KERNEL__ | ||
7 | |||
8 | /* | ||
9 | * Space reservation ioctls and argument structure | ||
10 | * are designed to be compatible with the legacy XFS ioctls. | ||
11 | */ | ||
12 | struct space_resv { | ||
13 | __s16 l_type; | ||
14 | __s16 l_whence; | ||
15 | __s64 l_start; | ||
16 | __s64 l_len; /* len == 0 means until end of file */ | ||
17 | __s32 l_sysid; | ||
18 | __u32 l_pid; | ||
19 | __s32 l_pad[4]; /* reserved area */ | ||
20 | }; | ||
21 | |||
22 | #define FS_IOC_RESVSP _IOW('X', 40, struct space_resv) | ||
23 | #define FS_IOC_RESVSP64 _IOW('X', 42, struct space_resv) | ||
24 | |||
25 | #endif /* __KERNEL__ */ | ||
26 | |||
6 | #endif /* _FALLOC_H_ */ | 27 | #endif /* _FALLOC_H_ */ |
diff --git a/include/linux/firewire.h b/include/linux/firewire.h index e584b7215e8b..9823946adbc5 100644 --- a/include/linux/firewire.h +++ b/include/linux/firewire.h | |||
@@ -3,6 +3,7 @@ | |||
3 | 3 | ||
4 | #include <linux/completion.h> | 4 | #include <linux/completion.h> |
5 | #include <linux/device.h> | 5 | #include <linux/device.h> |
6 | #include <linux/dma-mapping.h> | ||
6 | #include <linux/kernel.h> | 7 | #include <linux/kernel.h> |
7 | #include <linux/kref.h> | 8 | #include <linux/kref.h> |
8 | #include <linux/list.h> | 9 | #include <linux/list.h> |
@@ -355,4 +356,90 @@ int fw_run_transaction(struct fw_card *card, int tcode, int destination_id, | |||
355 | int generation, int speed, unsigned long long offset, | 356 | int generation, int speed, unsigned long long offset, |
356 | void *payload, size_t length); | 357 | void *payload, size_t length); |
357 | 358 | ||
359 | static inline int fw_stream_packet_destination_id(int tag, int channel, int sy) | ||
360 | { | ||
361 | return tag << 14 | channel << 8 | sy; | ||
362 | } | ||
363 | |||
364 | struct fw_descriptor { | ||
365 | struct list_head link; | ||
366 | size_t length; | ||
367 | u32 immediate; | ||
368 | u32 key; | ||
369 | const u32 *data; | ||
370 | }; | ||
371 | |||
372 | int fw_core_add_descriptor(struct fw_descriptor *desc); | ||
373 | void fw_core_remove_descriptor(struct fw_descriptor *desc); | ||
374 | |||
375 | /* | ||
376 | * The iso packet format allows for an immediate header/payload part | ||
377 | * stored in 'header' immediately after the packet info plus an | ||
378 | * indirect payload part that is pointer to by the 'payload' field. | ||
379 | * Applications can use one or the other or both to implement simple | ||
380 | * low-bandwidth streaming (e.g. audio) or more advanced | ||
381 | * scatter-gather streaming (e.g. assembling video frame automatically). | ||
382 | */ | ||
383 | struct fw_iso_packet { | ||
384 | u16 payload_length; /* Length of indirect payload. */ | ||
385 | u32 interrupt:1; /* Generate interrupt on this packet */ | ||
386 | u32 skip:1; /* Set to not send packet at all. */ | ||
387 | u32 tag:2; | ||
388 | u32 sy:4; | ||
389 | u32 header_length:8; /* Length of immediate header. */ | ||
390 | u32 header[0]; | ||
391 | }; | ||
392 | |||
393 | #define FW_ISO_CONTEXT_TRANSMIT 0 | ||
394 | #define FW_ISO_CONTEXT_RECEIVE 1 | ||
395 | |||
396 | #define FW_ISO_CONTEXT_MATCH_TAG0 1 | ||
397 | #define FW_ISO_CONTEXT_MATCH_TAG1 2 | ||
398 | #define FW_ISO_CONTEXT_MATCH_TAG2 4 | ||
399 | #define FW_ISO_CONTEXT_MATCH_TAG3 8 | ||
400 | #define FW_ISO_CONTEXT_MATCH_ALL_TAGS 15 | ||
401 | |||
402 | /* | ||
403 | * An iso buffer is just a set of pages mapped for DMA in the | ||
404 | * specified direction. Since the pages are to be used for DMA, they | ||
405 | * are not mapped into the kernel virtual address space. We store the | ||
406 | * DMA address in the page private. The helper function | ||
407 | * fw_iso_buffer_map() will map the pages into a given vma. | ||
408 | */ | ||
409 | struct fw_iso_buffer { | ||
410 | enum dma_data_direction direction; | ||
411 | struct page **pages; | ||
412 | int page_count; | ||
413 | }; | ||
414 | |||
415 | int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card, | ||
416 | int page_count, enum dma_data_direction direction); | ||
417 | void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer, struct fw_card *card); | ||
418 | |||
419 | struct fw_iso_context; | ||
420 | typedef void (*fw_iso_callback_t)(struct fw_iso_context *context, | ||
421 | u32 cycle, size_t header_length, | ||
422 | void *header, void *data); | ||
423 | struct fw_iso_context { | ||
424 | struct fw_card *card; | ||
425 | int type; | ||
426 | int channel; | ||
427 | int speed; | ||
428 | size_t header_size; | ||
429 | fw_iso_callback_t callback; | ||
430 | void *callback_data; | ||
431 | }; | ||
432 | |||
433 | struct fw_iso_context *fw_iso_context_create(struct fw_card *card, | ||
434 | int type, int channel, int speed, size_t header_size, | ||
435 | fw_iso_callback_t callback, void *callback_data); | ||
436 | int fw_iso_context_queue(struct fw_iso_context *ctx, | ||
437 | struct fw_iso_packet *packet, | ||
438 | struct fw_iso_buffer *buffer, | ||
439 | unsigned long payload); | ||
440 | int fw_iso_context_start(struct fw_iso_context *ctx, | ||
441 | int cycle, int sync, int tags); | ||
442 | int fw_iso_context_stop(struct fw_iso_context *ctx); | ||
443 | void fw_iso_context_destroy(struct fw_iso_context *ctx); | ||
444 | |||
358 | #endif /* _LINUX_FIREWIRE_H */ | 445 | #endif /* _LINUX_FIREWIRE_H */ |
diff --git a/include/linux/fs.h b/include/linux/fs.h index 74a57938c880..0872372184fe 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h | |||
@@ -710,6 +710,9 @@ static inline int mapping_writably_mapped(struct address_space *mapping) | |||
710 | #define i_size_ordered_init(inode) do { } while (0) | 710 | #define i_size_ordered_init(inode) do { } while (0) |
711 | #endif | 711 | #endif |
712 | 712 | ||
713 | struct posix_acl; | ||
714 | #define ACL_NOT_CACHED ((void *)(-1)) | ||
715 | |||
713 | struct inode { | 716 | struct inode { |
714 | struct hlist_node i_hash; | 717 | struct hlist_node i_hash; |
715 | struct list_head i_list; | 718 | struct list_head i_list; |
@@ -773,6 +776,10 @@ struct inode { | |||
773 | #ifdef CONFIG_SECURITY | 776 | #ifdef CONFIG_SECURITY |
774 | void *i_security; | 777 | void *i_security; |
775 | #endif | 778 | #endif |
779 | #ifdef CONFIG_FS_POSIX_ACL | ||
780 | struct posix_acl *i_acl; | ||
781 | struct posix_acl *i_default_acl; | ||
782 | #endif | ||
776 | void *i_private; /* fs or device private pointer */ | 783 | void *i_private; /* fs or device private pointer */ |
777 | }; | 784 | }; |
778 | 785 | ||
@@ -1107,6 +1114,7 @@ extern void locks_copy_lock(struct file_lock *, struct file_lock *); | |||
1107 | extern void __locks_copy_lock(struct file_lock *, const struct file_lock *); | 1114 | extern void __locks_copy_lock(struct file_lock *, const struct file_lock *); |
1108 | extern void locks_remove_posix(struct file *, fl_owner_t); | 1115 | extern void locks_remove_posix(struct file *, fl_owner_t); |
1109 | extern void locks_remove_flock(struct file *); | 1116 | extern void locks_remove_flock(struct file *); |
1117 | extern void locks_release_private(struct file_lock *); | ||
1110 | extern void posix_test_lock(struct file *, struct file_lock *); | 1118 | extern void posix_test_lock(struct file *, struct file_lock *); |
1111 | extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); | 1119 | extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); |
1112 | extern int posix_lock_file_wait(struct file *, struct file_lock *); | 1120 | extern int posix_lock_file_wait(struct file *, struct file_lock *); |
@@ -1905,6 +1913,8 @@ static inline int break_lease(struct inode *inode, unsigned int mode) | |||
1905 | 1913 | ||
1906 | extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs, | 1914 | extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs, |
1907 | struct file *filp); | 1915 | struct file *filp); |
1916 | extern int do_fallocate(struct file *file, int mode, loff_t offset, | ||
1917 | loff_t len); | ||
1908 | extern long do_sys_open(int dfd, const char __user *filename, int flags, | 1918 | extern long do_sys_open(int dfd, const char __user *filename, int flags, |
1909 | int mode); | 1919 | int mode); |
1910 | extern struct file *filp_open(const char *, int, int); | 1920 | extern struct file *filp_open(const char *, int, int); |
@@ -1913,6 +1923,10 @@ extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, | |||
1913 | extern int filp_close(struct file *, fl_owner_t id); | 1923 | extern int filp_close(struct file *, fl_owner_t id); |
1914 | extern char * getname(const char __user *); | 1924 | extern char * getname(const char __user *); |
1915 | 1925 | ||
1926 | /* fs/ioctl.c */ | ||
1927 | |||
1928 | extern int ioctl_preallocate(struct file *filp, void __user *argp); | ||
1929 | |||
1916 | /* fs/dcache.c */ | 1930 | /* fs/dcache.c */ |
1917 | extern void __init vfs_caches_init_early(void); | 1931 | extern void __init vfs_caches_init_early(void); |
1918 | extern void __init vfs_caches_init(unsigned long); | 1932 | extern void __init vfs_caches_init(unsigned long); |
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h index 39b95c56587e..dc3b1328aaeb 100644 --- a/include/linux/ftrace.h +++ b/include/linux/ftrace.h | |||
@@ -362,6 +362,7 @@ struct ftrace_ret_stack { | |||
362 | unsigned long func; | 362 | unsigned long func; |
363 | unsigned long long calltime; | 363 | unsigned long long calltime; |
364 | unsigned long long subtime; | 364 | unsigned long long subtime; |
365 | unsigned long fp; | ||
365 | }; | 366 | }; |
366 | 367 | ||
367 | /* | 368 | /* |
@@ -372,7 +373,8 @@ struct ftrace_ret_stack { | |||
372 | extern void return_to_handler(void); | 373 | extern void return_to_handler(void); |
373 | 374 | ||
374 | extern int | 375 | extern int |
375 | ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth); | 376 | ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth, |
377 | unsigned long frame_pointer); | ||
376 | 378 | ||
377 | /* | 379 | /* |
378 | * Sometimes we don't want to trace a function with the function | 380 | * Sometimes we don't want to trace a function with the function |
diff --git a/include/linux/gameport.h b/include/linux/gameport.h index 0cd825f7363a..1bc08541c2b9 100644 --- a/include/linux/gameport.h +++ b/include/linux/gameport.h | |||
@@ -11,6 +11,7 @@ | |||
11 | 11 | ||
12 | #ifdef __KERNEL__ | 12 | #ifdef __KERNEL__ |
13 | #include <asm/io.h> | 13 | #include <asm/io.h> |
14 | #include <linux/types.h> | ||
14 | #include <linux/list.h> | 15 | #include <linux/list.h> |
15 | #include <linux/mutex.h> | 16 | #include <linux/mutex.h> |
16 | #include <linux/device.h> | 17 | #include <linux/device.h> |
@@ -62,7 +63,7 @@ struct gameport_driver { | |||
62 | 63 | ||
63 | struct device_driver driver; | 64 | struct device_driver driver; |
64 | 65 | ||
65 | unsigned int ignore; | 66 | bool ignore; |
66 | }; | 67 | }; |
67 | #define to_gameport_driver(d) container_of(d, struct gameport_driver, driver) | 68 | #define to_gameport_driver(d) container_of(d, struct gameport_driver, driver) |
68 | 69 | ||
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h index 7400900de94a..54648e625efd 100644 --- a/include/linux/hrtimer.h +++ b/include/linux/hrtimer.h | |||
@@ -21,6 +21,7 @@ | |||
21 | #include <linux/list.h> | 21 | #include <linux/list.h> |
22 | #include <linux/wait.h> | 22 | #include <linux/wait.h> |
23 | #include <linux/percpu.h> | 23 | #include <linux/percpu.h> |
24 | #include <linux/timer.h> | ||
24 | 25 | ||
25 | 26 | ||
26 | struct hrtimer_clock_base; | 27 | struct hrtimer_clock_base; |
@@ -447,6 +448,8 @@ extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf, | |||
447 | 448 | ||
448 | static inline void timer_stats_account_hrtimer(struct hrtimer *timer) | 449 | static inline void timer_stats_account_hrtimer(struct hrtimer *timer) |
449 | { | 450 | { |
451 | if (likely(!timer->start_pid)) | ||
452 | return; | ||
450 | timer_stats_update_stats(timer, timer->start_pid, timer->start_site, | 453 | timer_stats_update_stats(timer, timer->start_pid, timer->start_site, |
451 | timer->function, timer->start_comm, 0); | 454 | timer->function, timer->start_comm, 0); |
452 | } | 455 | } |
@@ -456,6 +459,8 @@ extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer, | |||
456 | 459 | ||
457 | static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer) | 460 | static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer) |
458 | { | 461 | { |
462 | if (likely(!timer_stats_active)) | ||
463 | return; | ||
459 | __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0)); | 464 | __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0)); |
460 | } | 465 | } |
461 | 466 | ||
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h index a05a5ef33391..2723513a5651 100644 --- a/include/linux/hugetlb.h +++ b/include/linux/hugetlb.h | |||
@@ -33,7 +33,7 @@ void hugetlb_report_meminfo(struct seq_file *); | |||
33 | int hugetlb_report_node_meminfo(int, char *); | 33 | int hugetlb_report_node_meminfo(int, char *); |
34 | unsigned long hugetlb_total_pages(void); | 34 | unsigned long hugetlb_total_pages(void); |
35 | int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, | 35 | int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, |
36 | unsigned long address, int write_access); | 36 | unsigned long address, unsigned int flags); |
37 | int hugetlb_reserve_pages(struct inode *inode, long from, long to, | 37 | int hugetlb_reserve_pages(struct inode *inode, long from, long to, |
38 | struct vm_area_struct *vma, | 38 | struct vm_area_struct *vma, |
39 | int acctflags); | 39 | int acctflags); |
@@ -98,7 +98,7 @@ static inline void hugetlb_report_meminfo(struct seq_file *m) | |||
98 | #define pud_huge(x) 0 | 98 | #define pud_huge(x) 0 |
99 | #define is_hugepage_only_range(mm, addr, len) 0 | 99 | #define is_hugepage_only_range(mm, addr, len) 0 |
100 | #define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; }) | 100 | #define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; }) |
101 | #define hugetlb_fault(mm, vma, addr, write) ({ BUG(); 0; }) | 101 | #define hugetlb_fault(mm, vma, addr, flags) ({ BUG(); 0; }) |
102 | 102 | ||
103 | #define hugetlb_change_protection(vma, address, end, newprot) | 103 | #define hugetlb_change_protection(vma, address, end, newprot) |
104 | 104 | ||
diff --git a/include/linux/i2c.h b/include/linux/i2c.h index ad2580596033..f4784c0fe975 100644 --- a/include/linux/i2c.h +++ b/include/linux/i2c.h | |||
@@ -47,6 +47,7 @@ struct i2c_driver; | |||
47 | union i2c_smbus_data; | 47 | union i2c_smbus_data; |
48 | struct i2c_board_info; | 48 | struct i2c_board_info; |
49 | 49 | ||
50 | #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) | ||
50 | /* | 51 | /* |
51 | * The master routines are the ones normally used to transmit data to devices | 52 | * The master routines are the ones normally used to transmit data to devices |
52 | * on a bus (or read from them). Apart from two basic transfer functions to | 53 | * on a bus (or read from them). Apart from two basic transfer functions to |
@@ -93,6 +94,7 @@ extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, | |||
93 | extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, | 94 | extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, |
94 | u8 command, u8 length, | 95 | u8 command, u8 length, |
95 | const u8 *values); | 96 | const u8 *values); |
97 | #endif /* I2C */ | ||
96 | 98 | ||
97 | /** | 99 | /** |
98 | * struct i2c_driver - represent an I2C device driver | 100 | * struct i2c_driver - represent an I2C device driver |
@@ -100,9 +102,8 @@ extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, | |||
100 | * @class: What kind of i2c device we instantiate (for detect) | 102 | * @class: What kind of i2c device we instantiate (for detect) |
101 | * @attach_adapter: Callback for bus addition (for legacy drivers) | 103 | * @attach_adapter: Callback for bus addition (for legacy drivers) |
102 | * @detach_adapter: Callback for bus removal (for legacy drivers) | 104 | * @detach_adapter: Callback for bus removal (for legacy drivers) |
103 | * @detach_client: Callback for device removal (for legacy drivers) | 105 | * @probe: Callback for device binding |
104 | * @probe: Callback for device binding (new-style drivers) | 106 | * @remove: Callback for device unbinding |
105 | * @remove: Callback for device unbinding (new-style drivers) | ||
106 | * @shutdown: Callback for device shutdown | 107 | * @shutdown: Callback for device shutdown |
107 | * @suspend: Callback for device suspend | 108 | * @suspend: Callback for device suspend |
108 | * @resume: Callback for device resume | 109 | * @resume: Callback for device resume |
@@ -137,26 +138,14 @@ struct i2c_driver { | |||
137 | int id; | 138 | int id; |
138 | unsigned int class; | 139 | unsigned int class; |
139 | 140 | ||
140 | /* Notifies the driver that a new bus has appeared. This routine | 141 | /* Notifies the driver that a new bus has appeared or is about to be |
141 | * can be used by the driver to test if the bus meets its conditions | 142 | * removed. You should avoid using this if you can, it will probably |
142 | * & seek for the presence of the chip(s) it supports. If found, it | 143 | * be removed in a near future. |
143 | * registers the client(s) that are on the bus to the i2c admin. via | ||
144 | * i2c_attach_client. (LEGACY I2C DRIVERS ONLY) | ||
145 | */ | 144 | */ |
146 | int (*attach_adapter)(struct i2c_adapter *); | 145 | int (*attach_adapter)(struct i2c_adapter *); |
147 | int (*detach_adapter)(struct i2c_adapter *); | 146 | int (*detach_adapter)(struct i2c_adapter *); |
148 | 147 | ||
149 | /* tells the driver that a client is about to be deleted & gives it | 148 | /* Standard driver model interfaces */ |
150 | * the chance to remove its private data. Also, if the client struct | ||
151 | * has been dynamically allocated by the driver in the function above, | ||
152 | * it must be freed here. (LEGACY I2C DRIVERS ONLY) | ||
153 | */ | ||
154 | int (*detach_client)(struct i2c_client *) __deprecated; | ||
155 | |||
156 | /* Standard driver model interfaces, for "new style" i2c drivers. | ||
157 | * With the driver model, device enumeration is NEVER done by drivers; | ||
158 | * it's done by infrastructure. (NEW STYLE DRIVERS ONLY) | ||
159 | */ | ||
160 | int (*probe)(struct i2c_client *, const struct i2c_device_id *); | 149 | int (*probe)(struct i2c_client *, const struct i2c_device_id *); |
161 | int (*remove)(struct i2c_client *); | 150 | int (*remove)(struct i2c_client *); |
162 | 151 | ||
@@ -191,9 +180,8 @@ struct i2c_driver { | |||
191 | * @driver: device's driver, hence pointer to access routines | 180 | * @driver: device's driver, hence pointer to access routines |
192 | * @dev: Driver model device node for the slave. | 181 | * @dev: Driver model device node for the slave. |
193 | * @irq: indicates the IRQ generated by this device (if any) | 182 | * @irq: indicates the IRQ generated by this device (if any) |
194 | * @list: list of active/busy clients (DEPRECATED) | 183 | * @detected: member of an i2c_driver.clients list or i2c-core's |
195 | * @detected: member of an i2c_driver.clients list | 184 | * userspace_devices list |
196 | * @released: used to synchronize client releases & detaches and references | ||
197 | * | 185 | * |
198 | * An i2c_client identifies a single device (i.e. chip) connected to an | 186 | * An i2c_client identifies a single device (i.e. chip) connected to an |
199 | * i2c bus. The behaviour exposed to Linux is defined by the driver | 187 | * i2c bus. The behaviour exposed to Linux is defined by the driver |
@@ -209,9 +197,7 @@ struct i2c_client { | |||
209 | struct i2c_driver *driver; /* and our access routines */ | 197 | struct i2c_driver *driver; /* and our access routines */ |
210 | struct device dev; /* the device structure */ | 198 | struct device dev; /* the device structure */ |
211 | int irq; /* irq issued by device */ | 199 | int irq; /* irq issued by device */ |
212 | struct list_head list; /* DEPRECATED */ | ||
213 | struct list_head detected; | 200 | struct list_head detected; |
214 | struct completion released; | ||
215 | }; | 201 | }; |
216 | #define to_i2c_client(d) container_of(d, struct i2c_client, dev) | 202 | #define to_i2c_client(d) container_of(d, struct i2c_client, dev) |
217 | 203 | ||
@@ -248,11 +234,10 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data) | |||
248 | * that, such as chip type, configuration, associated IRQ, and so on. | 234 | * that, such as chip type, configuration, associated IRQ, and so on. |
249 | * | 235 | * |
250 | * i2c_board_info is used to build tables of information listing I2C devices | 236 | * i2c_board_info is used to build tables of information listing I2C devices |
251 | * that are present. This information is used to grow the driver model tree | 237 | * that are present. This information is used to grow the driver model tree. |
252 | * for "new style" I2C drivers. For mainboards this is done statically using | 238 | * For mainboards this is done statically using i2c_register_board_info(); |
253 | * i2c_register_board_info(); bus numbers identify adapters that aren't | 239 | * bus numbers identify adapters that aren't yet available. For add-on boards, |
254 | * yet available. For add-on boards, i2c_new_device() does this dynamically | 240 | * i2c_new_device() does this dynamically with the adapter already known. |
255 | * with the adapter already known. | ||
256 | */ | 241 | */ |
257 | struct i2c_board_info { | 242 | struct i2c_board_info { |
258 | char type[I2C_NAME_SIZE]; | 243 | char type[I2C_NAME_SIZE]; |
@@ -277,6 +262,7 @@ struct i2c_board_info { | |||
277 | .type = dev_type, .addr = (dev_addr) | 262 | .type = dev_type, .addr = (dev_addr) |
278 | 263 | ||
279 | 264 | ||
265 | #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) | ||
280 | /* Add-on boards should register/unregister their devices; e.g. a board | 266 | /* Add-on boards should register/unregister their devices; e.g. a board |
281 | * with integrated I2C, a config eeprom, sensors, and a codec that's | 267 | * with integrated I2C, a config eeprom, sensors, and a codec that's |
282 | * used in conjunction with the primary hardware. | 268 | * used in conjunction with the primary hardware. |
@@ -300,6 +286,7 @@ extern struct i2c_client * | |||
300 | i2c_new_dummy(struct i2c_adapter *adap, u16 address); | 286 | i2c_new_dummy(struct i2c_adapter *adap, u16 address); |
301 | 287 | ||
302 | extern void i2c_unregister_device(struct i2c_client *); | 288 | extern void i2c_unregister_device(struct i2c_client *); |
289 | #endif /* I2C */ | ||
303 | 290 | ||
304 | /* Mainboard arch_initcall() code should register all its I2C devices. | 291 | /* Mainboard arch_initcall() code should register all its I2C devices. |
305 | * This is done at arch_initcall time, before declaring any i2c adapters. | 292 | * This is done at arch_initcall time, before declaring any i2c adapters. |
@@ -316,7 +303,7 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info, | |||
316 | { | 303 | { |
317 | return 0; | 304 | return 0; |
318 | } | 305 | } |
319 | #endif | 306 | #endif /* I2C_BOARDINFO */ |
320 | 307 | ||
321 | /* | 308 | /* |
322 | * The following structs are for those who like to implement new bus drivers: | 309 | * The following structs are for those who like to implement new bus drivers: |
@@ -352,21 +339,15 @@ struct i2c_adapter { | |||
352 | const struct i2c_algorithm *algo; /* the algorithm to access the bus */ | 339 | const struct i2c_algorithm *algo; /* the algorithm to access the bus */ |
353 | void *algo_data; | 340 | void *algo_data; |
354 | 341 | ||
355 | /* --- administration stuff. */ | ||
356 | int (*client_register)(struct i2c_client *) __deprecated; | ||
357 | int (*client_unregister)(struct i2c_client *) __deprecated; | ||
358 | |||
359 | /* data fields that are valid for all devices */ | 342 | /* data fields that are valid for all devices */ |
360 | u8 level; /* nesting level for lockdep */ | 343 | u8 level; /* nesting level for lockdep */ |
361 | struct mutex bus_lock; | 344 | struct mutex bus_lock; |
362 | struct mutex clist_lock; | ||
363 | 345 | ||
364 | int timeout; /* in jiffies */ | 346 | int timeout; /* in jiffies */ |
365 | int retries; | 347 | int retries; |
366 | struct device dev; /* the adapter device */ | 348 | struct device dev; /* the adapter device */ |
367 | 349 | ||
368 | int nr; | 350 | int nr; |
369 | struct list_head clients; /* DEPRECATED */ | ||
370 | char name[48]; | 351 | char name[48]; |
371 | struct completion dev_released; | 352 | struct completion dev_released; |
372 | }; | 353 | }; |
@@ -412,11 +393,16 @@ struct i2c_client_address_data { | |||
412 | /* The numbers to use to set I2C bus address */ | 393 | /* The numbers to use to set I2C bus address */ |
413 | #define ANY_I2C_BUS 0xffff | 394 | #define ANY_I2C_BUS 0xffff |
414 | 395 | ||
396 | /* Construct an I2C_CLIENT_END-terminated array of i2c addresses */ | ||
397 | #define I2C_ADDRS(addr, addrs...) \ | ||
398 | ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END }) | ||
399 | |||
415 | 400 | ||
416 | /* ----- functions exported by i2c.o */ | 401 | /* ----- functions exported by i2c.o */ |
417 | 402 | ||
418 | /* administration... | 403 | /* administration... |
419 | */ | 404 | */ |
405 | #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) | ||
420 | extern int i2c_add_adapter(struct i2c_adapter *); | 406 | extern int i2c_add_adapter(struct i2c_adapter *); |
421 | extern int i2c_del_adapter(struct i2c_adapter *); | 407 | extern int i2c_del_adapter(struct i2c_adapter *); |
422 | extern int i2c_add_numbered_adapter(struct i2c_adapter *); | 408 | extern int i2c_add_numbered_adapter(struct i2c_adapter *); |
@@ -429,11 +415,6 @@ static inline int i2c_add_driver(struct i2c_driver *driver) | |||
429 | return i2c_register_driver(THIS_MODULE, driver); | 415 | return i2c_register_driver(THIS_MODULE, driver); |
430 | } | 416 | } |
431 | 417 | ||
432 | /* These are deprecated, your driver should use the standard .probe() | ||
433 | * and .remove() methods instead. */ | ||
434 | extern int __deprecated i2c_attach_client(struct i2c_client *); | ||
435 | extern int __deprecated i2c_detach_client(struct i2c_client *); | ||
436 | |||
437 | extern struct i2c_client *i2c_use_client(struct i2c_client *client); | 418 | extern struct i2c_client *i2c_use_client(struct i2c_client *client); |
438 | extern void i2c_release_client(struct i2c_client *client); | 419 | extern void i2c_release_client(struct i2c_client *client); |
439 | 420 | ||
@@ -442,14 +423,6 @@ extern void i2c_release_client(struct i2c_client *client); | |||
442 | extern void i2c_clients_command(struct i2c_adapter *adap, | 423 | extern void i2c_clients_command(struct i2c_adapter *adap, |
443 | unsigned int cmd, void *arg); | 424 | unsigned int cmd, void *arg); |
444 | 425 | ||
445 | /* Detect function. It iterates over all possible addresses itself. | ||
446 | * It will only call found_proc if some client is connected at the | ||
447 | * specific address (unless a 'force' matched); | ||
448 | */ | ||
449 | extern int i2c_probe(struct i2c_adapter *adapter, | ||
450 | const struct i2c_client_address_data *address_data, | ||
451 | int (*found_proc) (struct i2c_adapter *, int, int)); | ||
452 | |||
453 | extern struct i2c_adapter *i2c_get_adapter(int id); | 426 | extern struct i2c_adapter *i2c_get_adapter(int id); |
454 | extern void i2c_put_adapter(struct i2c_adapter *adap); | 427 | extern void i2c_put_adapter(struct i2c_adapter *adap); |
455 | 428 | ||
@@ -471,6 +444,7 @@ static inline int i2c_adapter_id(struct i2c_adapter *adap) | |||
471 | { | 444 | { |
472 | return adap->nr; | 445 | return adap->nr; |
473 | } | 446 | } |
447 | #endif /* I2C */ | ||
474 | #endif /* __KERNEL__ */ | 448 | #endif /* __KERNEL__ */ |
475 | 449 | ||
476 | /** | 450 | /** |
diff --git a/include/linux/i2c/lm8323.h b/include/linux/i2c/lm8323.h new file mode 100644 index 000000000000..478d668bc590 --- /dev/null +++ b/include/linux/i2c/lm8323.h | |||
@@ -0,0 +1,46 @@ | |||
1 | /* | ||
2 | * lm8323.h - Configuration for LM8323 keypad driver. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify | ||
5 | * it under the terms of the GNU General Public License as published by | ||
6 | * the Free Software Foundation (version 2 of the License only). | ||
7 | * | ||
8 | * This program is distributed in the hope that it will be useful, | ||
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
11 | * GNU General Public License for more details. | ||
12 | * | ||
13 | * You should have received a copy of the GNU General Public License | ||
14 | * along with this program; if not, write to the Free Software | ||
15 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
16 | */ | ||
17 | |||
18 | #ifndef __LINUX_LM8323_H | ||
19 | #define __LINUX_LM8323_H | ||
20 | |||
21 | #include <linux/types.h> | ||
22 | |||
23 | /* | ||
24 | * Largest keycode that the chip can send, plus one, | ||
25 | * so keys can be mapped directly at the index of the | ||
26 | * LM8323 keycode instead of subtracting one. | ||
27 | */ | ||
28 | #define LM8323_KEYMAP_SIZE (0x7f + 1) | ||
29 | |||
30 | #define LM8323_NUM_PWMS 3 | ||
31 | |||
32 | struct lm8323_platform_data { | ||
33 | int debounce_time; /* Time to watch for key bouncing, in ms. */ | ||
34 | int active_time; /* Idle time until sleep, in ms. */ | ||
35 | |||
36 | int size_x; | ||
37 | int size_y; | ||
38 | bool repeat; | ||
39 | const unsigned short *keymap; | ||
40 | |||
41 | const char *pwm_names[LM8323_NUM_PWMS]; | ||
42 | |||
43 | const char *name; /* Device name. */ | ||
44 | }; | ||
45 | |||
46 | #endif /* __LINUX_LM8323_H */ | ||
diff --git a/include/linux/icmpv6.h b/include/linux/icmpv6.h index 10d701eec484..b6a85183c333 100644 --- a/include/linux/icmpv6.h +++ b/include/linux/icmpv6.h | |||
@@ -175,16 +175,16 @@ struct icmp6_filter { | |||
175 | 175 | ||
176 | 176 | ||
177 | extern void icmpv6_send(struct sk_buff *skb, | 177 | extern void icmpv6_send(struct sk_buff *skb, |
178 | int type, int code, | 178 | u8 type, u8 code, |
179 | __u32 info, | 179 | __u32 info, |
180 | struct net_device *dev); | 180 | struct net_device *dev); |
181 | 181 | ||
182 | extern int icmpv6_init(void); | 182 | extern int icmpv6_init(void); |
183 | extern int icmpv6_err_convert(int type, int code, | 183 | extern int icmpv6_err_convert(u8 type, u8 code, |
184 | int *err); | 184 | int *err); |
185 | extern void icmpv6_cleanup(void); | 185 | extern void icmpv6_cleanup(void); |
186 | extern void icmpv6_param_prob(struct sk_buff *skb, | 186 | extern void icmpv6_param_prob(struct sk_buff *skb, |
187 | int code, int pos); | 187 | u8 code, int pos); |
188 | 188 | ||
189 | struct flowi; | 189 | struct flowi; |
190 | struct in6_addr; | 190 | struct in6_addr; |
diff --git a/include/linux/ide.h b/include/linux/ide.h index a6c6a2fad7c8..cf1f3888067c 100644 --- a/include/linux/ide.h +++ b/include/linux/ide.h | |||
@@ -157,12 +157,6 @@ enum { | |||
157 | #define REQ_UNPARK_HEADS 0x23 | 157 | #define REQ_UNPARK_HEADS 0x23 |
158 | 158 | ||
159 | /* | 159 | /* |
160 | * Check for an interrupt and acknowledge the interrupt status | ||
161 | */ | ||
162 | struct hwif_s; | ||
163 | typedef int (ide_ack_intr_t)(struct hwif_s *); | ||
164 | |||
165 | /* | ||
166 | * hwif_chipset_t is used to keep track of the specific hardware | 160 | * hwif_chipset_t is used to keep track of the specific hardware |
167 | * chipset used by each IDE interface, if known. | 161 | * chipset used by each IDE interface, if known. |
168 | */ | 162 | */ |
@@ -185,7 +179,6 @@ struct ide_hw { | |||
185 | }; | 179 | }; |
186 | 180 | ||
187 | int irq; /* our irq number */ | 181 | int irq; /* our irq number */ |
188 | ide_ack_intr_t *ack_intr; /* acknowledge interrupt */ | ||
189 | struct device *dev, *parent; | 182 | struct device *dev, *parent; |
190 | unsigned long config; | 183 | unsigned long config; |
191 | }; | 184 | }; |
@@ -331,11 +324,6 @@ enum { | |||
331 | PC_FLAG_WRITING = (1 << 6), | 324 | PC_FLAG_WRITING = (1 << 6), |
332 | }; | 325 | }; |
333 | 326 | ||
334 | /* | ||
335 | * With each packet command, we allocate a buffer of IDE_PC_BUFFER_SIZE bytes. | ||
336 | * This is used for several packet commands (not for READ/WRITE commands). | ||
337 | */ | ||
338 | #define IDE_PC_BUFFER_SIZE 64 | ||
339 | #define ATAPI_WAIT_PC (60 * HZ) | 327 | #define ATAPI_WAIT_PC (60 * HZ) |
340 | 328 | ||
341 | struct ide_atapi_pc { | 329 | struct ide_atapi_pc { |
@@ -347,12 +335,6 @@ struct ide_atapi_pc { | |||
347 | 335 | ||
348 | /* bytes to transfer */ | 336 | /* bytes to transfer */ |
349 | int req_xfer; | 337 | int req_xfer; |
350 | /* bytes actually transferred */ | ||
351 | int xferred; | ||
352 | |||
353 | /* data buffer */ | ||
354 | u8 *buf; | ||
355 | int buf_size; | ||
356 | 338 | ||
357 | /* the corresponding request */ | 339 | /* the corresponding request */ |
358 | struct request *rq; | 340 | struct request *rq; |
@@ -363,8 +345,6 @@ struct ide_atapi_pc { | |||
363 | * those are more or less driver-specific and some of them are subject | 345 | * those are more or less driver-specific and some of them are subject |
364 | * to change/removal later. | 346 | * to change/removal later. |
365 | */ | 347 | */ |
366 | u8 pc_buf[IDE_PC_BUFFER_SIZE]; | ||
367 | |||
368 | unsigned long timeout; | 348 | unsigned long timeout; |
369 | }; | 349 | }; |
370 | 350 | ||
@@ -552,7 +532,7 @@ struct ide_drive_s { | |||
552 | 532 | ||
553 | unsigned int bios_cyl; /* BIOS/fdisk/LILO number of cyls */ | 533 | unsigned int bios_cyl; /* BIOS/fdisk/LILO number of cyls */ |
554 | unsigned int cyl; /* "real" number of cyls */ | 534 | unsigned int cyl; /* "real" number of cyls */ |
555 | unsigned int drive_data; /* used by set_pio_mode/dev_select() */ | 535 | void *drive_data; /* used by set_pio_mode/dev_select() */ |
556 | unsigned int failures; /* current failure count */ | 536 | unsigned int failures; /* current failure count */ |
557 | unsigned int max_failures; /* maximum allowed failure count */ | 537 | unsigned int max_failures; /* maximum allowed failure count */ |
558 | u64 probed_capacity;/* initial/native media capacity */ | 538 | u64 probed_capacity;/* initial/native media capacity */ |
@@ -649,6 +629,7 @@ struct ide_port_ops { | |||
649 | void (*maskproc)(ide_drive_t *, int); | 629 | void (*maskproc)(ide_drive_t *, int); |
650 | void (*quirkproc)(ide_drive_t *); | 630 | void (*quirkproc)(ide_drive_t *); |
651 | void (*clear_irq)(ide_drive_t *); | 631 | void (*clear_irq)(ide_drive_t *); |
632 | int (*test_irq)(struct hwif_s *); | ||
652 | 633 | ||
653 | u8 (*mdma_filter)(ide_drive_t *); | 634 | u8 (*mdma_filter)(ide_drive_t *); |
654 | u8 (*udma_filter)(ide_drive_t *); | 635 | u8 (*udma_filter)(ide_drive_t *); |
@@ -674,6 +655,10 @@ struct ide_dma_ops { | |||
674 | u8 (*dma_sff_read_status)(struct hwif_s *); | 655 | u8 (*dma_sff_read_status)(struct hwif_s *); |
675 | }; | 656 | }; |
676 | 657 | ||
658 | enum { | ||
659 | IDE_PFLAG_PROBING = (1 << 0), | ||
660 | }; | ||
661 | |||
677 | struct ide_host; | 662 | struct ide_host; |
678 | 663 | ||
679 | typedef struct hwif_s { | 664 | typedef struct hwif_s { |
@@ -690,6 +675,8 @@ typedef struct hwif_s { | |||
690 | 675 | ||
691 | ide_drive_t *devices[MAX_DRIVES + 1]; | 676 | ide_drive_t *devices[MAX_DRIVES + 1]; |
692 | 677 | ||
678 | unsigned long port_flags; | ||
679 | |||
693 | u8 major; /* our major number */ | 680 | u8 major; /* our major number */ |
694 | u8 index; /* 0 for ide0; 1 for ide1; ... */ | 681 | u8 index; /* 0 for ide0; 1 for ide1; ... */ |
695 | u8 channel; /* for dual-port chips: 0=primary, 1=secondary */ | 682 | u8 channel; /* for dual-port chips: 0=primary, 1=secondary */ |
@@ -708,8 +695,6 @@ typedef struct hwif_s { | |||
708 | 695 | ||
709 | struct device *dev; | 696 | struct device *dev; |
710 | 697 | ||
711 | ide_ack_intr_t *ack_intr; | ||
712 | |||
713 | void (*rw_disk)(ide_drive_t *, struct request *); | 698 | void (*rw_disk)(ide_drive_t *, struct request *); |
714 | 699 | ||
715 | const struct ide_tp_ops *tp_ops; | 700 | const struct ide_tp_ops *tp_ops; |
@@ -1130,6 +1115,8 @@ void SELECT_MASK(ide_drive_t *, int); | |||
1130 | u8 ide_read_error(ide_drive_t *); | 1115 | u8 ide_read_error(ide_drive_t *); |
1131 | void ide_read_bcount_and_ireason(ide_drive_t *, u16 *, u8 *); | 1116 | void ide_read_bcount_and_ireason(ide_drive_t *, u16 *, u8 *); |
1132 | 1117 | ||
1118 | int ide_check_ireason(ide_drive_t *, struct request *, int, int, int); | ||
1119 | |||
1133 | int ide_check_atapi_device(ide_drive_t *, const char *); | 1120 | int ide_check_atapi_device(ide_drive_t *, const char *); |
1134 | 1121 | ||
1135 | void ide_init_pc(struct ide_atapi_pc *); | 1122 | void ide_init_pc(struct ide_atapi_pc *); |
@@ -1154,7 +1141,8 @@ enum { | |||
1154 | REQ_IDETAPE_WRITE = (1 << 3), | 1141 | REQ_IDETAPE_WRITE = (1 << 3), |
1155 | }; | 1142 | }; |
1156 | 1143 | ||
1157 | int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *); | 1144 | int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *, |
1145 | void *, unsigned int); | ||
1158 | 1146 | ||
1159 | int ide_do_test_unit_ready(ide_drive_t *, struct gendisk *); | 1147 | int ide_do_test_unit_ready(ide_drive_t *, struct gendisk *); |
1160 | int ide_do_start_stop(ide_drive_t *, struct gendisk *, int); | 1148 | int ide_do_start_stop(ide_drive_t *, struct gendisk *, int); |
@@ -1373,7 +1361,6 @@ int ide_in_drive_list(u16 *, const struct drive_list_entry *); | |||
1373 | #ifdef CONFIG_BLK_DEV_IDEDMA | 1361 | #ifdef CONFIG_BLK_DEV_IDEDMA |
1374 | int ide_dma_good_drive(ide_drive_t *); | 1362 | int ide_dma_good_drive(ide_drive_t *); |
1375 | int __ide_dma_bad_drive(ide_drive_t *); | 1363 | int __ide_dma_bad_drive(ide_drive_t *); |
1376 | int ide_id_dma_bug(ide_drive_t *); | ||
1377 | 1364 | ||
1378 | u8 ide_find_dma_mode(ide_drive_t *, u8); | 1365 | u8 ide_find_dma_mode(ide_drive_t *, u8); |
1379 | 1366 | ||
@@ -1414,7 +1401,6 @@ void ide_dma_lost_irq(ide_drive_t *); | |||
1414 | ide_startstop_t ide_dma_timeout_retry(ide_drive_t *, int); | 1401 | ide_startstop_t ide_dma_timeout_retry(ide_drive_t *, int); |
1415 | 1402 | ||
1416 | #else | 1403 | #else |
1417 | static inline int ide_id_dma_bug(ide_drive_t *drive) { return 0; } | ||
1418 | static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; } | 1404 | static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; } |
1419 | static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; } | 1405 | static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; } |
1420 | static inline void ide_dma_off_quietly(ide_drive_t *drive) { ; } | 1406 | static inline void ide_dma_off_quietly(ide_drive_t *drive) { ; } |
@@ -1524,6 +1510,7 @@ int ide_timing_compute(ide_drive_t *, u8, struct ide_timing *, int, int); | |||
1524 | int ide_scan_pio_blacklist(char *); | 1510 | int ide_scan_pio_blacklist(char *); |
1525 | const char *ide_xfer_verbose(u8); | 1511 | const char *ide_xfer_verbose(u8); |
1526 | u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8); | 1512 | u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8); |
1513 | int ide_pio_need_iordy(ide_drive_t *, const u8); | ||
1527 | int ide_set_pio_mode(ide_drive_t *, u8); | 1514 | int ide_set_pio_mode(ide_drive_t *, u8); |
1528 | int ide_set_dma_mode(ide_drive_t *, u8); | 1515 | int ide_set_dma_mode(ide_drive_t *, u8); |
1529 | void ide_set_pio(ide_drive_t *, u8); | 1516 | void ide_set_pio(ide_drive_t *, u8); |
@@ -1561,6 +1548,16 @@ static inline ide_drive_t *ide_get_pair_dev(ide_drive_t *drive) | |||
1561 | return (peer->dev_flags & IDE_DFLAG_PRESENT) ? peer : NULL; | 1548 | return (peer->dev_flags & IDE_DFLAG_PRESENT) ? peer : NULL; |
1562 | } | 1549 | } |
1563 | 1550 | ||
1551 | static inline void *ide_get_drivedata(ide_drive_t *drive) | ||
1552 | { | ||
1553 | return drive->drive_data; | ||
1554 | } | ||
1555 | |||
1556 | static inline void ide_set_drivedata(ide_drive_t *drive, void *data) | ||
1557 | { | ||
1558 | drive->drive_data = data; | ||
1559 | } | ||
1560 | |||
1564 | #define ide_port_for_each_dev(i, dev, port) \ | 1561 | #define ide_port_for_each_dev(i, dev, port) \ |
1565 | for ((i) = 0; ((dev) = (port)->devices[i]) || (i) < MAX_DRIVES; (i)++) | 1562 | for ((i) = 0; ((dev) = (port)->devices[i]) || (i) < MAX_DRIVES; (i)++) |
1566 | 1563 | ||
diff --git a/include/linux/ima.h b/include/linux/ima.h index b1b827d091a9..0e3f2a4c25f6 100644 --- a/include/linux/ima.h +++ b/include/linux/ima.h | |||
@@ -24,6 +24,7 @@ extern int ima_path_check(struct path *path, int mask, int update_counts); | |||
24 | extern void ima_file_free(struct file *file); | 24 | extern void ima_file_free(struct file *file); |
25 | extern int ima_file_mmap(struct file *file, unsigned long prot); | 25 | extern int ima_file_mmap(struct file *file, unsigned long prot); |
26 | extern void ima_counts_get(struct file *file); | 26 | extern void ima_counts_get(struct file *file); |
27 | extern void ima_counts_put(struct path *path, int mask); | ||
27 | 28 | ||
28 | #else | 29 | #else |
29 | static inline int ima_bprm_check(struct linux_binprm *bprm) | 30 | static inline int ima_bprm_check(struct linux_binprm *bprm) |
@@ -60,5 +61,10 @@ static inline void ima_counts_get(struct file *file) | |||
60 | { | 61 | { |
61 | return; | 62 | return; |
62 | } | 63 | } |
64 | |||
65 | static inline void ima_counts_put(struct path *path, int mask) | ||
66 | { | ||
67 | return; | ||
68 | } | ||
63 | #endif /* CONFIG_IMA_H */ | 69 | #endif /* CONFIG_IMA_H */ |
64 | #endif /* _LINUX_IMA_H */ | 70 | #endif /* _LINUX_IMA_H */ |
diff --git a/include/linux/input.h b/include/linux/input.h index 6fed4f6a9c9e..8b3bc3e0d146 100644 --- a/include/linux/input.h +++ b/include/linux/input.h | |||
@@ -53,6 +53,7 @@ struct input_absinfo { | |||
53 | __s32 maximum; | 53 | __s32 maximum; |
54 | __s32 fuzz; | 54 | __s32 fuzz; |
55 | __s32 flat; | 55 | __s32 flat; |
56 | __s32 resolution; | ||
56 | }; | 57 | }; |
57 | 58 | ||
58 | #define EVIOCGVERSION _IOR('E', 0x01, int) /* get driver version */ | 59 | #define EVIOCGVERSION _IOR('E', 0x01, int) /* get driver version */ |
@@ -1109,6 +1110,7 @@ struct input_dev { | |||
1109 | int absmin[ABS_MAX + 1]; | 1110 | int absmin[ABS_MAX + 1]; |
1110 | int absfuzz[ABS_MAX + 1]; | 1111 | int absfuzz[ABS_MAX + 1]; |
1111 | int absflat[ABS_MAX + 1]; | 1112 | int absflat[ABS_MAX + 1]; |
1113 | int absres[ABS_MAX + 1]; | ||
1112 | 1114 | ||
1113 | int (*open)(struct input_dev *dev); | 1115 | int (*open)(struct input_dev *dev); |
1114 | void (*close)(struct input_dev *dev); | 1116 | void (*close)(struct input_dev *dev); |
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h index aa8c53171233..482dc91fd53a 100644 --- a/include/linux/intel-iommu.h +++ b/include/linux/intel-iommu.h | |||
@@ -53,6 +53,7 @@ | |||
53 | #define DMAR_PHMLIMIT_REG 0x78 /* pmrr high limit */ | 53 | #define DMAR_PHMLIMIT_REG 0x78 /* pmrr high limit */ |
54 | #define DMAR_IQH_REG 0x80 /* Invalidation queue head register */ | 54 | #define DMAR_IQH_REG 0x80 /* Invalidation queue head register */ |
55 | #define DMAR_IQT_REG 0x88 /* Invalidation queue tail register */ | 55 | #define DMAR_IQT_REG 0x88 /* Invalidation queue tail register */ |
56 | #define DMAR_IQ_SHIFT 4 /* Invalidation queue head/tail shift */ | ||
56 | #define DMAR_IQA_REG 0x90 /* Invalidation queue addr register */ | 57 | #define DMAR_IQA_REG 0x90 /* Invalidation queue addr register */ |
57 | #define DMAR_ICS_REG 0x98 /* Invalidation complete status register */ | 58 | #define DMAR_ICS_REG 0x98 /* Invalidation complete status register */ |
58 | #define DMAR_IRTA_REG 0xb8 /* Interrupt remapping table addr register */ | 59 | #define DMAR_IRTA_REG 0xb8 /* Interrupt remapping table addr register */ |
@@ -120,8 +121,10 @@ static inline void dmar_writeq(void __iomem *addr, u64 val) | |||
120 | (ecap_iotlb_offset(e) + ecap_niotlb_iunits(e) * 16) | 121 | (ecap_iotlb_offset(e) + ecap_niotlb_iunits(e) * 16) |
121 | #define ecap_coherent(e) ((e) & 0x1) | 122 | #define ecap_coherent(e) ((e) & 0x1) |
122 | #define ecap_qis(e) ((e) & 0x2) | 123 | #define ecap_qis(e) ((e) & 0x2) |
124 | #define ecap_pass_through(e) ((e >> 6) & 0x1) | ||
123 | #define ecap_eim_support(e) ((e >> 4) & 0x1) | 125 | #define ecap_eim_support(e) ((e >> 4) & 0x1) |
124 | #define ecap_ir_support(e) ((e >> 3) & 0x1) | 126 | #define ecap_ir_support(e) ((e >> 3) & 0x1) |
127 | #define ecap_dev_iotlb_support(e) (((e) >> 2) & 0x1) | ||
125 | #define ecap_max_handle_mask(e) ((e >> 20) & 0xf) | 128 | #define ecap_max_handle_mask(e) ((e >> 20) & 0xf) |
126 | #define ecap_sc_support(e) ((e >> 7) & 0x1) /* Snooping Control */ | 129 | #define ecap_sc_support(e) ((e >> 7) & 0x1) /* Snooping Control */ |
127 | 130 | ||
@@ -197,6 +200,8 @@ static inline void dmar_writeq(void __iomem *addr, u64 val) | |||
197 | #define DMA_FSTS_PPF ((u32)2) | 200 | #define DMA_FSTS_PPF ((u32)2) |
198 | #define DMA_FSTS_PFO ((u32)1) | 201 | #define DMA_FSTS_PFO ((u32)1) |
199 | #define DMA_FSTS_IQE (1 << 4) | 202 | #define DMA_FSTS_IQE (1 << 4) |
203 | #define DMA_FSTS_ICE (1 << 5) | ||
204 | #define DMA_FSTS_ITE (1 << 6) | ||
200 | #define dma_fsts_fault_record_index(s) (((s) >> 8) & 0xff) | 205 | #define dma_fsts_fault_record_index(s) (((s) >> 8) & 0xff) |
201 | 206 | ||
202 | /* FRCD_REG, 32 bits access */ | 207 | /* FRCD_REG, 32 bits access */ |
@@ -225,7 +230,8 @@ do { \ | |||
225 | enum { | 230 | enum { |
226 | QI_FREE, | 231 | QI_FREE, |
227 | QI_IN_USE, | 232 | QI_IN_USE, |
228 | QI_DONE | 233 | QI_DONE, |
234 | QI_ABORT | ||
229 | }; | 235 | }; |
230 | 236 | ||
231 | #define QI_CC_TYPE 0x1 | 237 | #define QI_CC_TYPE 0x1 |
@@ -254,6 +260,12 @@ enum { | |||
254 | #define QI_CC_DID(did) (((u64)did) << 16) | 260 | #define QI_CC_DID(did) (((u64)did) << 16) |
255 | #define QI_CC_GRAN(gran) (((u64)gran) >> (DMA_CCMD_INVL_GRANU_OFFSET-4)) | 261 | #define QI_CC_GRAN(gran) (((u64)gran) >> (DMA_CCMD_INVL_GRANU_OFFSET-4)) |
256 | 262 | ||
263 | #define QI_DEV_IOTLB_SID(sid) ((u64)((sid) & 0xffff) << 32) | ||
264 | #define QI_DEV_IOTLB_QDEP(qdep) (((qdep) & 0x1f) << 16) | ||
265 | #define QI_DEV_IOTLB_ADDR(addr) ((u64)(addr) & VTD_PAGE_MASK) | ||
266 | #define QI_DEV_IOTLB_SIZE 1 | ||
267 | #define QI_DEV_IOTLB_MAX_INVS 32 | ||
268 | |||
257 | struct qi_desc { | 269 | struct qi_desc { |
258 | u64 low, high; | 270 | u64 low, high; |
259 | }; | 271 | }; |
@@ -280,10 +292,10 @@ struct ir_table { | |||
280 | #endif | 292 | #endif |
281 | 293 | ||
282 | struct iommu_flush { | 294 | struct iommu_flush { |
283 | int (*flush_context)(struct intel_iommu *iommu, u16 did, u16 sid, u8 fm, | 295 | void (*flush_context)(struct intel_iommu *iommu, u16 did, u16 sid, |
284 | u64 type, int non_present_entry_flush); | 296 | u8 fm, u64 type); |
285 | int (*flush_iotlb)(struct intel_iommu *iommu, u16 did, u64 addr, | 297 | void (*flush_iotlb)(struct intel_iommu *iommu, u16 did, u64 addr, |
286 | unsigned int size_order, u64 type, int non_present_entry_flush); | 298 | unsigned int size_order, u64 type); |
287 | }; | 299 | }; |
288 | 300 | ||
289 | enum { | 301 | enum { |
@@ -302,6 +314,7 @@ struct intel_iommu { | |||
302 | spinlock_t register_lock; /* protect register handling */ | 314 | spinlock_t register_lock; /* protect register handling */ |
303 | int seq_id; /* sequence id of the iommu */ | 315 | int seq_id; /* sequence id of the iommu */ |
304 | int agaw; /* agaw of this iommu */ | 316 | int agaw; /* agaw of this iommu */ |
317 | int msagaw; /* max sagaw of this iommu */ | ||
305 | unsigned int irq; | 318 | unsigned int irq; |
306 | unsigned char name[13]; /* Device Name */ | 319 | unsigned char name[13]; /* Device Name */ |
307 | 320 | ||
@@ -329,6 +342,7 @@ static inline void __iommu_flush_cache( | |||
329 | } | 342 | } |
330 | 343 | ||
331 | extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev); | 344 | extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev); |
345 | extern int dmar_find_matched_atsr_unit(struct pci_dev *dev); | ||
332 | 346 | ||
333 | extern int alloc_iommu(struct dmar_drhd_unit *drhd); | 347 | extern int alloc_iommu(struct dmar_drhd_unit *drhd); |
334 | extern void free_iommu(struct intel_iommu *iommu); | 348 | extern void free_iommu(struct intel_iommu *iommu); |
@@ -337,11 +351,12 @@ extern void dmar_disable_qi(struct intel_iommu *iommu); | |||
337 | extern int dmar_reenable_qi(struct intel_iommu *iommu); | 351 | extern int dmar_reenable_qi(struct intel_iommu *iommu); |
338 | extern void qi_global_iec(struct intel_iommu *iommu); | 352 | extern void qi_global_iec(struct intel_iommu *iommu); |
339 | 353 | ||
340 | extern int qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, | 354 | extern void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, |
341 | u8 fm, u64 type, int non_present_entry_flush); | 355 | u8 fm, u64 type); |
342 | extern int qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr, | 356 | extern void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr, |
343 | unsigned int size_order, u64 type, | 357 | unsigned int size_order, u64 type); |
344 | int non_present_entry_flush); | 358 | extern void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 qdep, |
359 | u64 addr, unsigned mask); | ||
345 | 360 | ||
346 | extern int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu); | 361 | extern int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu); |
347 | 362 | ||
diff --git a/include/linux/ioport.h b/include/linux/ioport.h index 32e4b2f72294..786e7b8cece9 100644 --- a/include/linux/ioport.h +++ b/include/linux/ioport.h | |||
@@ -49,6 +49,8 @@ struct resource_list { | |||
49 | #define IORESOURCE_SIZEALIGN 0x00020000 /* size indicates alignment */ | 49 | #define IORESOURCE_SIZEALIGN 0x00020000 /* size indicates alignment */ |
50 | #define IORESOURCE_STARTALIGN 0x00040000 /* start field is alignment */ | 50 | #define IORESOURCE_STARTALIGN 0x00040000 /* start field is alignment */ |
51 | 51 | ||
52 | #define IORESOURCE_MEM_64 0x00100000 | ||
53 | |||
52 | #define IORESOURCE_EXCLUSIVE 0x08000000 /* Userland may not map this resource */ | 54 | #define IORESOURCE_EXCLUSIVE 0x08000000 /* Userland may not map this resource */ |
53 | #define IORESOURCE_DISABLED 0x10000000 | 55 | #define IORESOURCE_DISABLED 0x10000000 |
54 | #define IORESOURCE_UNSET 0x20000000 | 56 | #define IORESOURCE_UNSET 0x20000000 |
diff --git a/include/linux/irq.h b/include/linux/irq.h index 1e50c34f0062..cb2e77a3f7f7 100644 --- a/include/linux/irq.h +++ b/include/linux/irq.h | |||
@@ -157,7 +157,7 @@ struct irq_2_iommu; | |||
157 | * @irqs_unhandled: stats field for spurious unhandled interrupts | 157 | * @irqs_unhandled: stats field for spurious unhandled interrupts |
158 | * @lock: locking for SMP | 158 | * @lock: locking for SMP |
159 | * @affinity: IRQ affinity on SMP | 159 | * @affinity: IRQ affinity on SMP |
160 | * @cpu: cpu index useful for balancing | 160 | * @node: node index useful for balancing |
161 | * @pending_mask: pending rebalanced interrupts | 161 | * @pending_mask: pending rebalanced interrupts |
162 | * @threads_active: number of irqaction threads currently running | 162 | * @threads_active: number of irqaction threads currently running |
163 | * @wait_for_threads: wait queue for sync_irq to wait for threaded handlers | 163 | * @wait_for_threads: wait queue for sync_irq to wait for threaded handlers |
@@ -423,7 +423,7 @@ extern int set_irq_msi(unsigned int irq, struct msi_desc *entry); | |||
423 | /** | 423 | /** |
424 | * alloc_desc_masks - allocate cpumasks for irq_desc | 424 | * alloc_desc_masks - allocate cpumasks for irq_desc |
425 | * @desc: pointer to irq_desc struct | 425 | * @desc: pointer to irq_desc struct |
426 | * @cpu: cpu which will be handling the cpumasks | 426 | * @node: node which will be handling the cpumasks |
427 | * @boot: true if need bootmem | 427 | * @boot: true if need bootmem |
428 | * | 428 | * |
429 | * Allocates affinity and pending_mask cpumask if required. | 429 | * Allocates affinity and pending_mask cpumask if required. |
diff --git a/include/linux/kernel.h b/include/linux/kernel.h index c5a71c38a95f..d6320a3e8def 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h | |||
@@ -58,7 +58,7 @@ extern const char linux_proc_banner[]; | |||
58 | #define _RET_IP_ (unsigned long)__builtin_return_address(0) | 58 | #define _RET_IP_ (unsigned long)__builtin_return_address(0) |
59 | #define _THIS_IP_ ({ __label__ __here; __here: (unsigned long)&&__here; }) | 59 | #define _THIS_IP_ ({ __label__ __here; __here: (unsigned long)&&__here; }) |
60 | 60 | ||
61 | #ifdef CONFIG_LBD | 61 | #ifdef CONFIG_LBDAF |
62 | # include <asm/div64.h> | 62 | # include <asm/div64.h> |
63 | # define sector_div(a, b) do_div(a, b) | 63 | # define sector_div(a, b) do_div(a, b) |
64 | #else | 64 | #else |
@@ -303,6 +303,7 @@ extern int oops_in_progress; /* If set, an oops, panic(), BUG() or die() is in | |||
303 | extern int panic_timeout; | 303 | extern int panic_timeout; |
304 | extern int panic_on_oops; | 304 | extern int panic_on_oops; |
305 | extern int panic_on_unrecovered_nmi; | 305 | extern int panic_on_unrecovered_nmi; |
306 | extern int panic_on_io_nmi; | ||
306 | extern const char *print_tainted(void); | 307 | extern const char *print_tainted(void); |
307 | extern void add_taint(unsigned flag); | 308 | extern void add_taint(unsigned flag); |
308 | extern int test_taint(unsigned flag); | 309 | extern int test_taint(unsigned flag); |
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index aacc5449f586..16713dc672e4 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h | |||
@@ -125,6 +125,7 @@ struct kvm_kernel_irq_routing_entry { | |||
125 | struct kvm { | 125 | struct kvm { |
126 | struct mutex lock; /* protects the vcpus array and APIC accesses */ | 126 | struct mutex lock; /* protects the vcpus array and APIC accesses */ |
127 | spinlock_t mmu_lock; | 127 | spinlock_t mmu_lock; |
128 | spinlock_t requests_lock; | ||
128 | struct rw_semaphore slots_lock; | 129 | struct rw_semaphore slots_lock; |
129 | struct mm_struct *mm; /* userspace tied to this vm */ | 130 | struct mm_struct *mm; /* userspace tied to this vm */ |
130 | int nmemslots; | 131 | int nmemslots; |
diff --git a/include/linux/leds-lp3944.h b/include/linux/leds-lp3944.h new file mode 100644 index 000000000000..afc9f9fd70f5 --- /dev/null +++ b/include/linux/leds-lp3944.h | |||
@@ -0,0 +1,53 @@ | |||
1 | /* | ||
2 | * leds-lp3944.h - platform data structure for lp3944 led controller | ||
3 | * | ||
4 | * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it> | ||
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 | |||
12 | #ifndef __LINUX_LEDS_LP3944_H | ||
13 | #define __LINUX_LEDS_LP3944_H | ||
14 | |||
15 | #include <linux/leds.h> | ||
16 | #include <linux/workqueue.h> | ||
17 | |||
18 | #define LP3944_LED0 0 | ||
19 | #define LP3944_LED1 1 | ||
20 | #define LP3944_LED2 2 | ||
21 | #define LP3944_LED3 3 | ||
22 | #define LP3944_LED4 4 | ||
23 | #define LP3944_LED5 5 | ||
24 | #define LP3944_LED6 6 | ||
25 | #define LP3944_LED7 7 | ||
26 | #define LP3944_LEDS_MAX 8 | ||
27 | |||
28 | #define LP3944_LED_STATUS_MASK 0x03 | ||
29 | enum lp3944_status { | ||
30 | LP3944_LED_STATUS_OFF = 0x0, | ||
31 | LP3944_LED_STATUS_ON = 0x1, | ||
32 | LP3944_LED_STATUS_DIM0 = 0x2, | ||
33 | LP3944_LED_STATUS_DIM1 = 0x3 | ||
34 | }; | ||
35 | |||
36 | enum lp3944_type { | ||
37 | LP3944_LED_TYPE_NONE, | ||
38 | LP3944_LED_TYPE_LED, | ||
39 | LP3944_LED_TYPE_LED_INVERTED, | ||
40 | }; | ||
41 | |||
42 | struct lp3944_led { | ||
43 | char *name; | ||
44 | enum lp3944_type type; | ||
45 | enum lp3944_status status; | ||
46 | }; | ||
47 | |||
48 | struct lp3944_platform_data { | ||
49 | struct lp3944_led leds[LP3944_LEDS_MAX]; | ||
50 | u8 leds_size; | ||
51 | }; | ||
52 | |||
53 | #endif /* __LINUX_LEDS_LP3944_H */ | ||
diff --git a/include/linux/leds.h b/include/linux/leds.h index 376fe07732ea..d8bf9665e70c 100644 --- a/include/linux/leds.h +++ b/include/linux/leds.h | |||
@@ -45,7 +45,10 @@ struct led_classdev { | |||
45 | /* Get LED brightness level */ | 45 | /* Get LED brightness level */ |
46 | enum led_brightness (*brightness_get)(struct led_classdev *led_cdev); | 46 | enum led_brightness (*brightness_get)(struct led_classdev *led_cdev); |
47 | 47 | ||
48 | /* Activate hardware accelerated blink */ | 48 | /* Activate hardware accelerated blink, delays are in |
49 | * miliseconds and if none is provided then a sensible default | ||
50 | * should be chosen. The call can adjust the timings if it can't | ||
51 | * match the values specified exactly. */ | ||
49 | int (*blink_set)(struct led_classdev *led_cdev, | 52 | int (*blink_set)(struct led_classdev *led_cdev, |
50 | unsigned long *delay_on, | 53 | unsigned long *delay_on, |
51 | unsigned long *delay_off); | 54 | unsigned long *delay_off); |
@@ -141,9 +144,14 @@ struct gpio_led { | |||
141 | const char *name; | 144 | const char *name; |
142 | const char *default_trigger; | 145 | const char *default_trigger; |
143 | unsigned gpio; | 146 | unsigned gpio; |
144 | u8 active_low : 1; | 147 | unsigned active_low : 1; |
145 | u8 retain_state_suspended : 1; | 148 | unsigned retain_state_suspended : 1; |
149 | unsigned default_state : 2; | ||
150 | /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */ | ||
146 | }; | 151 | }; |
152 | #define LEDS_GPIO_DEFSTATE_OFF 0 | ||
153 | #define LEDS_GPIO_DEFSTATE_ON 1 | ||
154 | #define LEDS_GPIO_DEFSTATE_KEEP 2 | ||
147 | 155 | ||
148 | struct gpio_led_platform_data { | 156 | struct gpio_led_platform_data { |
149 | int num_leds; | 157 | int num_leds; |
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h index 51855dfd8adb..c325b187966b 100644 --- a/include/linux/lockd/lockd.h +++ b/include/linux/lockd/lockd.h | |||
@@ -195,7 +195,7 @@ extern struct svc_procedure nlmsvc_procedures4[]; | |||
195 | extern int nlmsvc_grace_period; | 195 | extern int nlmsvc_grace_period; |
196 | extern unsigned long nlmsvc_timeout; | 196 | extern unsigned long nlmsvc_timeout; |
197 | extern int nsm_use_hostnames; | 197 | extern int nsm_use_hostnames; |
198 | extern int nsm_local_state; | 198 | extern u32 nsm_local_state; |
199 | 199 | ||
200 | /* | 200 | /* |
201 | * Lockd client functions | 201 | * Lockd client functions |
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h index da5a5a1f4cd2..b25d1b53df0d 100644 --- a/include/linux/lockdep.h +++ b/include/linux/lockdep.h | |||
@@ -258,6 +258,16 @@ extern void lockdep_init_map(struct lockdep_map *lock, const char *name, | |||
258 | #define lockdep_set_subclass(lock, sub) \ | 258 | #define lockdep_set_subclass(lock, sub) \ |
259 | lockdep_init_map(&(lock)->dep_map, #lock, \ | 259 | lockdep_init_map(&(lock)->dep_map, #lock, \ |
260 | (lock)->dep_map.key, sub) | 260 | (lock)->dep_map.key, sub) |
261 | /* | ||
262 | * Compare locking classes | ||
263 | */ | ||
264 | #define lockdep_match_class(lock, key) lockdep_match_key(&(lock)->dep_map, key) | ||
265 | |||
266 | static inline int lockdep_match_key(struct lockdep_map *lock, | ||
267 | struct lock_class_key *key) | ||
268 | { | ||
269 | return lock->key == key; | ||
270 | } | ||
261 | 271 | ||
262 | /* | 272 | /* |
263 | * Acquire a lock. | 273 | * Acquire a lock. |
@@ -326,6 +336,11 @@ static inline void lockdep_on(void) | |||
326 | #define lockdep_set_class_and_subclass(lock, key, sub) \ | 336 | #define lockdep_set_class_and_subclass(lock, key, sub) \ |
327 | do { (void)(key); } while (0) | 337 | do { (void)(key); } while (0) |
328 | #define lockdep_set_subclass(lock, sub) do { } while (0) | 338 | #define lockdep_set_subclass(lock, sub) do { } while (0) |
339 | /* | ||
340 | * We don't define lockdep_match_class() and lockdep_match_key() for !LOCKDEP | ||
341 | * case since the result is not well defined and the caller should rather | ||
342 | * #ifdef the call himself. | ||
343 | */ | ||
329 | 344 | ||
330 | # define INIT_LOCKDEP | 345 | # define INIT_LOCKDEP |
331 | # define lockdep_reset() do { debug_locks = 1; } while (0) | 346 | # define lockdep_reset() do { debug_locks = 1; } while (0) |
diff --git a/include/linux/max17040_battery.h b/include/linux/max17040_battery.h new file mode 100644 index 000000000000..ad97b06cf930 --- /dev/null +++ b/include/linux/max17040_battery.h | |||
@@ -0,0 +1,19 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2009 Samsung Electronics | ||
3 | * Minkyu Kang <mk7.kang@samsung.com> | ||
4 | * | ||
5 | * This program is free software; you 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 | |||
10 | #ifndef __MAX17040_BATTERY_H_ | ||
11 | #define __MAX17040_BATTERY_H_ | ||
12 | |||
13 | struct max17040_platform_data { | ||
14 | int (*battery_online)(void); | ||
15 | int (*charger_online)(void); | ||
16 | int (*charger_enable)(void); | ||
17 | }; | ||
18 | |||
19 | #endif | ||
diff --git a/include/linux/mm.h b/include/linux/mm.h index d88d6fc530ad..ba3a7cb1eaa0 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h | |||
@@ -810,11 +810,11 @@ extern int vmtruncate_range(struct inode * inode, loff_t offset, loff_t end); | |||
810 | 810 | ||
811 | #ifdef CONFIG_MMU | 811 | #ifdef CONFIG_MMU |
812 | extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma, | 812 | extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma, |
813 | unsigned long address, int write_access); | 813 | unsigned long address, unsigned int flags); |
814 | #else | 814 | #else |
815 | static inline int handle_mm_fault(struct mm_struct *mm, | 815 | static inline int handle_mm_fault(struct mm_struct *mm, |
816 | struct vm_area_struct *vma, unsigned long address, | 816 | struct vm_area_struct *vma, unsigned long address, |
817 | int write_access) | 817 | unsigned int flags) |
818 | { | 818 | { |
819 | /* should never happen if there's no MMU */ | 819 | /* should never happen if there's no MMU */ |
820 | BUG(); | 820 | BUG(); |
@@ -826,7 +826,7 @@ extern int make_pages_present(unsigned long addr, unsigned long end); | |||
826 | extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write); | 826 | extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write); |
827 | 827 | ||
828 | int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, | 828 | int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, |
829 | unsigned long start, int len, int write, int force, | 829 | unsigned long start, int nr_pages, int write, int force, |
830 | struct page **pages, struct vm_area_struct **vmas); | 830 | struct page **pages, struct vm_area_struct **vmas); |
831 | int get_user_pages_fast(unsigned long start, int nr_pages, int write, | 831 | int get_user_pages_fast(unsigned long start, int nr_pages, int write, |
832 | struct page **pages); | 832 | struct page **pages); |
@@ -854,6 +854,12 @@ extern int mprotect_fixup(struct vm_area_struct *vma, | |||
854 | unsigned long end, unsigned long newflags); | 854 | unsigned long end, unsigned long newflags); |
855 | 855 | ||
856 | /* | 856 | /* |
857 | * doesn't attempt to fault and will return short. | ||
858 | */ | ||
859 | int __get_user_pages_fast(unsigned long start, int nr_pages, int write, | ||
860 | struct page **pages); | ||
861 | |||
862 | /* | ||
857 | * A callback you can register to apply pressure to ageable caches. | 863 | * A callback you can register to apply pressure to ageable caches. |
858 | * | 864 | * |
859 | * 'shrink' is passed a count 'nr_to_scan' and a 'gfpmask'. It should | 865 | * 'shrink' is passed a count 'nr_to_scan' and a 'gfpmask'. It should |
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h index 3a059298cc19..3beb2592b03f 100644 --- a/include/linux/mnt_namespace.h +++ b/include/linux/mnt_namespace.h | |||
@@ -24,16 +24,10 @@ struct proc_mounts { | |||
24 | 24 | ||
25 | struct fs_struct; | 25 | struct fs_struct; |
26 | 26 | ||
27 | extern struct mnt_namespace *create_mnt_ns(struct vfsmount *mnt); | ||
27 | extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *, | 28 | extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *, |
28 | struct fs_struct *); | 29 | struct fs_struct *); |
29 | extern void __put_mnt_ns(struct mnt_namespace *ns); | 30 | extern void put_mnt_ns(struct mnt_namespace *ns); |
30 | |||
31 | static inline void put_mnt_ns(struct mnt_namespace *ns) | ||
32 | { | ||
33 | if (atomic_dec_and_lock(&ns->count, &vfsmount_lock)) | ||
34 | /* releases vfsmount_lock */ | ||
35 | __put_mnt_ns(ns); | ||
36 | } | ||
37 | 31 | ||
38 | static inline void exit_mnt_ns(struct task_struct *p) | 32 | static inline void exit_mnt_ns(struct task_struct *p) |
39 | { | 33 | { |
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h index 7efb9be34662..4030ebada49e 100644 --- a/include/linux/mtd/nand.h +++ b/include/linux/mtd/nand.h | |||
@@ -563,6 +563,7 @@ extern int nand_do_read(struct mtd_info *mtd, loff_t from, size_t len, | |||
563 | * @options: Option flags, e.g. 16bit buswidth | 563 | * @options: Option flags, e.g. 16bit buswidth |
564 | * @ecclayout: ecc layout info structure | 564 | * @ecclayout: ecc layout info structure |
565 | * @part_probe_types: NULL-terminated array of probe types | 565 | * @part_probe_types: NULL-terminated array of probe types |
566 | * @set_parts: platform specific function to set partitions | ||
566 | * @priv: hardware controller specific settings | 567 | * @priv: hardware controller specific settings |
567 | */ | 568 | */ |
568 | struct platform_nand_chip { | 569 | struct platform_nand_chip { |
@@ -574,26 +575,41 @@ struct platform_nand_chip { | |||
574 | int chip_delay; | 575 | int chip_delay; |
575 | unsigned int options; | 576 | unsigned int options; |
576 | const char **part_probe_types; | 577 | const char **part_probe_types; |
578 | void (*set_parts)(uint64_t size, | ||
579 | struct platform_nand_chip *chip); | ||
577 | void *priv; | 580 | void *priv; |
578 | }; | 581 | }; |
579 | 582 | ||
583 | /* Keep gcc happy */ | ||
584 | struct platform_device; | ||
585 | |||
580 | /** | 586 | /** |
581 | * struct platform_nand_ctrl - controller level device structure | 587 | * struct platform_nand_ctrl - controller level device structure |
588 | * @probe: platform specific function to probe/setup hardware | ||
589 | * @remove: platform specific function to remove/teardown hardware | ||
582 | * @hwcontrol: platform specific hardware control structure | 590 | * @hwcontrol: platform specific hardware control structure |
583 | * @dev_ready: platform specific function to read ready/busy pin | 591 | * @dev_ready: platform specific function to read ready/busy pin |
584 | * @select_chip: platform specific chip select function | 592 | * @select_chip: platform specific chip select function |
585 | * @cmd_ctrl: platform specific function for controlling | 593 | * @cmd_ctrl: platform specific function for controlling |
586 | * ALE/CLE/nCE. Also used to write command and address | 594 | * ALE/CLE/nCE. Also used to write command and address |
595 | * @write_buf: platform specific function for write buffer | ||
596 | * @read_buf: platform specific function for read buffer | ||
587 | * @priv: private data to transport driver specific settings | 597 | * @priv: private data to transport driver specific settings |
588 | * | 598 | * |
589 | * All fields are optional and depend on the hardware driver requirements | 599 | * All fields are optional and depend on the hardware driver requirements |
590 | */ | 600 | */ |
591 | struct platform_nand_ctrl { | 601 | struct platform_nand_ctrl { |
602 | int (*probe)(struct platform_device *pdev); | ||
603 | void (*remove)(struct platform_device *pdev); | ||
592 | void (*hwcontrol)(struct mtd_info *mtd, int cmd); | 604 | void (*hwcontrol)(struct mtd_info *mtd, int cmd); |
593 | int (*dev_ready)(struct mtd_info *mtd); | 605 | int (*dev_ready)(struct mtd_info *mtd); |
594 | void (*select_chip)(struct mtd_info *mtd, int chip); | 606 | void (*select_chip)(struct mtd_info *mtd, int chip); |
595 | void (*cmd_ctrl)(struct mtd_info *mtd, int dat, | 607 | void (*cmd_ctrl)(struct mtd_info *mtd, int dat, |
596 | unsigned int ctrl); | 608 | unsigned int ctrl); |
609 | void (*write_buf)(struct mtd_info *mtd, | ||
610 | const uint8_t *buf, int len); | ||
611 | void (*read_buf)(struct mtd_info *mtd, | ||
612 | uint8_t *buf, int len); | ||
597 | void *priv; | 613 | void *priv; |
598 | }; | 614 | }; |
599 | 615 | ||
diff --git a/include/linux/mtd/onenand.h b/include/linux/mtd/onenand.h index 9aa2a9149b58..8ed873374381 100644 --- a/include/linux/mtd/onenand.h +++ b/include/linux/mtd/onenand.h | |||
@@ -17,6 +17,7 @@ | |||
17 | #include <linux/mtd/onenand_regs.h> | 17 | #include <linux/mtd/onenand_regs.h> |
18 | #include <linux/mtd/bbm.h> | 18 | #include <linux/mtd/bbm.h> |
19 | 19 | ||
20 | #define MAX_DIES 2 | ||
20 | #define MAX_BUFFERRAM 2 | 21 | #define MAX_BUFFERRAM 2 |
21 | 22 | ||
22 | /* Scan and identify a OneNAND device */ | 23 | /* Scan and identify a OneNAND device */ |
@@ -51,7 +52,12 @@ struct onenand_bufferram { | |||
51 | /** | 52 | /** |
52 | * struct onenand_chip - OneNAND Private Flash Chip Data | 53 | * struct onenand_chip - OneNAND Private Flash Chip Data |
53 | * @base: [BOARDSPECIFIC] address to access OneNAND | 54 | * @base: [BOARDSPECIFIC] address to access OneNAND |
55 | * @dies: [INTERN][FLEX-ONENAND] number of dies on chip | ||
56 | * @boundary: [INTERN][FLEX-ONENAND] Boundary of the dies | ||
57 | * @diesize: [INTERN][FLEX-ONENAND] Size of the dies | ||
54 | * @chipsize: [INTERN] the size of one chip for multichip arrays | 58 | * @chipsize: [INTERN] the size of one chip for multichip arrays |
59 | * FIXME For Flex-OneNAND, chipsize holds maximum possible | ||
60 | * device size ie when all blocks are considered MLC | ||
55 | * @device_id: [INTERN] device ID | 61 | * @device_id: [INTERN] device ID |
56 | * @density_mask: chip density, used for DDP devices | 62 | * @density_mask: chip density, used for DDP devices |
57 | * @verstion_id: [INTERN] version ID | 63 | * @verstion_id: [INTERN] version ID |
@@ -68,6 +74,8 @@ struct onenand_bufferram { | |||
68 | * @command: [REPLACEABLE] hardware specific function for writing | 74 | * @command: [REPLACEABLE] hardware specific function for writing |
69 | * commands to the chip | 75 | * commands to the chip |
70 | * @wait: [REPLACEABLE] hardware specific function for wait on ready | 76 | * @wait: [REPLACEABLE] hardware specific function for wait on ready |
77 | * @bbt_wait: [REPLACEABLE] hardware specific function for bbt wait on ready | ||
78 | * @unlock_all: [REPLACEABLE] hardware specific function for unlock all | ||
71 | * @read_bufferram: [REPLACEABLE] hardware specific function for BufferRAM Area | 79 | * @read_bufferram: [REPLACEABLE] hardware specific function for BufferRAM Area |
72 | * @write_bufferram: [REPLACEABLE] hardware specific function for BufferRAM Area | 80 | * @write_bufferram: [REPLACEABLE] hardware specific function for BufferRAM Area |
73 | * @read_word: [REPLACEABLE] hardware specific function for read | 81 | * @read_word: [REPLACEABLE] hardware specific function for read |
@@ -92,9 +100,13 @@ struct onenand_bufferram { | |||
92 | */ | 100 | */ |
93 | struct onenand_chip { | 101 | struct onenand_chip { |
94 | void __iomem *base; | 102 | void __iomem *base; |
103 | unsigned dies; | ||
104 | unsigned boundary[MAX_DIES]; | ||
105 | loff_t diesize[MAX_DIES]; | ||
95 | unsigned int chipsize; | 106 | unsigned int chipsize; |
96 | unsigned int device_id; | 107 | unsigned int device_id; |
97 | unsigned int version_id; | 108 | unsigned int version_id; |
109 | unsigned int technology; | ||
98 | unsigned int density_mask; | 110 | unsigned int density_mask; |
99 | unsigned int options; | 111 | unsigned int options; |
100 | 112 | ||
@@ -108,6 +120,8 @@ struct onenand_chip { | |||
108 | 120 | ||
109 | int (*command)(struct mtd_info *mtd, int cmd, loff_t address, size_t len); | 121 | int (*command)(struct mtd_info *mtd, int cmd, loff_t address, size_t len); |
110 | int (*wait)(struct mtd_info *mtd, int state); | 122 | int (*wait)(struct mtd_info *mtd, int state); |
123 | int (*bbt_wait)(struct mtd_info *mtd, int state); | ||
124 | void (*unlock_all)(struct mtd_info *mtd); | ||
111 | int (*read_bufferram)(struct mtd_info *mtd, int area, | 125 | int (*read_bufferram)(struct mtd_info *mtd, int area, |
112 | unsigned char *buffer, int offset, size_t count); | 126 | unsigned char *buffer, int offset, size_t count); |
113 | int (*write_bufferram)(struct mtd_info *mtd, int area, | 127 | int (*write_bufferram)(struct mtd_info *mtd, int area, |
@@ -145,6 +159,8 @@ struct onenand_chip { | |||
145 | #define ONENAND_SET_BUFFERRAM0(this) (this->bufferram_index = 0) | 159 | #define ONENAND_SET_BUFFERRAM0(this) (this->bufferram_index = 0) |
146 | #define ONENAND_SET_BUFFERRAM1(this) (this->bufferram_index = 1) | 160 | #define ONENAND_SET_BUFFERRAM1(this) (this->bufferram_index = 1) |
147 | 161 | ||
162 | #define FLEXONENAND(this) \ | ||
163 | (this->device_id & DEVICE_IS_FLEXONENAND) | ||
148 | #define ONENAND_GET_SYS_CFG1(this) \ | 164 | #define ONENAND_GET_SYS_CFG1(this) \ |
149 | (this->read_word(this->base + ONENAND_REG_SYS_CFG1)) | 165 | (this->read_word(this->base + ONENAND_REG_SYS_CFG1)) |
150 | #define ONENAND_SET_SYS_CFG1(v, this) \ | 166 | #define ONENAND_SET_SYS_CFG1(v, this) \ |
@@ -153,6 +169,9 @@ struct onenand_chip { | |||
153 | #define ONENAND_IS_DDP(this) \ | 169 | #define ONENAND_IS_DDP(this) \ |
154 | (this->device_id & ONENAND_DEVICE_IS_DDP) | 170 | (this->device_id & ONENAND_DEVICE_IS_DDP) |
155 | 171 | ||
172 | #define ONENAND_IS_MLC(this) \ | ||
173 | (this->technology & ONENAND_TECHNOLOGY_IS_MLC) | ||
174 | |||
156 | #ifdef CONFIG_MTD_ONENAND_2X_PROGRAM | 175 | #ifdef CONFIG_MTD_ONENAND_2X_PROGRAM |
157 | #define ONENAND_IS_2PLANE(this) \ | 176 | #define ONENAND_IS_2PLANE(this) \ |
158 | (this->options & ONENAND_HAS_2PLANE) | 177 | (this->options & ONENAND_HAS_2PLANE) |
@@ -169,6 +188,7 @@ struct onenand_chip { | |||
169 | #define ONENAND_HAS_CONT_LOCK (0x0001) | 188 | #define ONENAND_HAS_CONT_LOCK (0x0001) |
170 | #define ONENAND_HAS_UNLOCK_ALL (0x0002) | 189 | #define ONENAND_HAS_UNLOCK_ALL (0x0002) |
171 | #define ONENAND_HAS_2PLANE (0x0004) | 190 | #define ONENAND_HAS_2PLANE (0x0004) |
191 | #define ONENAND_SKIP_UNLOCK_CHECK (0x0100) | ||
172 | #define ONENAND_PAGEBUF_ALLOC (0x1000) | 192 | #define ONENAND_PAGEBUF_ALLOC (0x1000) |
173 | #define ONENAND_OOBBUF_ALLOC (0x2000) | 193 | #define ONENAND_OOBBUF_ALLOC (0x2000) |
174 | 194 | ||
@@ -176,6 +196,7 @@ struct onenand_chip { | |||
176 | * OneNAND Flash Manufacturer ID Codes | 196 | * OneNAND Flash Manufacturer ID Codes |
177 | */ | 197 | */ |
178 | #define ONENAND_MFR_SAMSUNG 0xec | 198 | #define ONENAND_MFR_SAMSUNG 0xec |
199 | #define ONENAND_MFR_NUMONYX 0x20 | ||
179 | 200 | ||
180 | /** | 201 | /** |
181 | * struct onenand_manufacturers - NAND Flash Manufacturer ID Structure | 202 | * struct onenand_manufacturers - NAND Flash Manufacturer ID Structure |
@@ -189,5 +210,8 @@ struct onenand_manufacturers { | |||
189 | 210 | ||
190 | int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from, | 211 | int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from, |
191 | struct mtd_oob_ops *ops); | 212 | struct mtd_oob_ops *ops); |
213 | unsigned onenand_block(struct onenand_chip *this, loff_t addr); | ||
214 | loff_t onenand_addr(struct onenand_chip *this, int block); | ||
215 | int flexonenand_region(struct mtd_info *mtd, loff_t addr); | ||
192 | 216 | ||
193 | #endif /* __LINUX_MTD_ONENAND_H */ | 217 | #endif /* __LINUX_MTD_ONENAND_H */ |
diff --git a/include/linux/mtd/onenand_regs.h b/include/linux/mtd/onenand_regs.h index 0c6bbe28f38c..86a6bbef6465 100644 --- a/include/linux/mtd/onenand_regs.h +++ b/include/linux/mtd/onenand_regs.h | |||
@@ -67,6 +67,9 @@ | |||
67 | /* | 67 | /* |
68 | * Device ID Register F001h (R) | 68 | * Device ID Register F001h (R) |
69 | */ | 69 | */ |
70 | #define DEVICE_IS_FLEXONENAND (1 << 9) | ||
71 | #define FLEXONENAND_PI_MASK (0x3ff) | ||
72 | #define FLEXONENAND_PI_UNLOCK_SHIFT (14) | ||
70 | #define ONENAND_DEVICE_DENSITY_MASK (0xf) | 73 | #define ONENAND_DEVICE_DENSITY_MASK (0xf) |
71 | #define ONENAND_DEVICE_DENSITY_SHIFT (4) | 74 | #define ONENAND_DEVICE_DENSITY_SHIFT (4) |
72 | #define ONENAND_DEVICE_IS_DDP (1 << 3) | 75 | #define ONENAND_DEVICE_IS_DDP (1 << 3) |
@@ -84,6 +87,11 @@ | |||
84 | #define ONENAND_VERSION_PROCESS_SHIFT (8) | 87 | #define ONENAND_VERSION_PROCESS_SHIFT (8) |
85 | 88 | ||
86 | /* | 89 | /* |
90 | * Technology Register F006h (R) | ||
91 | */ | ||
92 | #define ONENAND_TECHNOLOGY_IS_MLC (1 << 0) | ||
93 | |||
94 | /* | ||
87 | * Start Address 1 F100h (R/W) & Start Address 2 F101h (R/W) | 95 | * Start Address 1 F100h (R/W) & Start Address 2 F101h (R/W) |
88 | */ | 96 | */ |
89 | #define ONENAND_DDP_SHIFT (15) | 97 | #define ONENAND_DDP_SHIFT (15) |
@@ -93,7 +101,8 @@ | |||
93 | /* | 101 | /* |
94 | * Start Address 8 F107h (R/W) | 102 | * Start Address 8 F107h (R/W) |
95 | */ | 103 | */ |
96 | #define ONENAND_FPA_MASK (0x3f) | 104 | /* Note: It's actually 0x3f in case of SLC */ |
105 | #define ONENAND_FPA_MASK (0x7f) | ||
97 | #define ONENAND_FPA_SHIFT (2) | 106 | #define ONENAND_FPA_SHIFT (2) |
98 | #define ONENAND_FSA_MASK (0x03) | 107 | #define ONENAND_FSA_MASK (0x03) |
99 | 108 | ||
@@ -105,7 +114,8 @@ | |||
105 | #define ONENAND_BSA_BOOTRAM (0 << 2) | 114 | #define ONENAND_BSA_BOOTRAM (0 << 2) |
106 | #define ONENAND_BSA_DATARAM0 (2 << 2) | 115 | #define ONENAND_BSA_DATARAM0 (2 << 2) |
107 | #define ONENAND_BSA_DATARAM1 (3 << 2) | 116 | #define ONENAND_BSA_DATARAM1 (3 << 2) |
108 | #define ONENAND_BSC_MASK (0x03) | 117 | /* Note: It's actually 0x03 in case of SLC */ |
118 | #define ONENAND_BSC_MASK (0x07) | ||
109 | 119 | ||
110 | /* | 120 | /* |
111 | * Command Register F220h (R/W) | 121 | * Command Register F220h (R/W) |
@@ -124,9 +134,13 @@ | |||
124 | #define ONENAND_CMD_RESET (0xF0) | 134 | #define ONENAND_CMD_RESET (0xF0) |
125 | #define ONENAND_CMD_OTP_ACCESS (0x65) | 135 | #define ONENAND_CMD_OTP_ACCESS (0x65) |
126 | #define ONENAND_CMD_READID (0x90) | 136 | #define ONENAND_CMD_READID (0x90) |
137 | #define FLEXONENAND_CMD_PI_UPDATE (0x05) | ||
138 | #define FLEXONENAND_CMD_PI_ACCESS (0x66) | ||
139 | #define FLEXONENAND_CMD_RECOVER_LSB (0x05) | ||
127 | 140 | ||
128 | /* NOTE: Those are not *REAL* commands */ | 141 | /* NOTE: Those are not *REAL* commands */ |
129 | #define ONENAND_CMD_BUFFERRAM (0x1978) | 142 | #define ONENAND_CMD_BUFFERRAM (0x1978) |
143 | #define FLEXONENAND_CMD_READ_PI (0x1985) | ||
130 | 144 | ||
131 | /* | 145 | /* |
132 | * System Configuration 1 Register F221h (R, R/W) | 146 | * System Configuration 1 Register F221h (R, R/W) |
@@ -192,10 +206,12 @@ | |||
192 | #define ONENAND_ECC_1BIT_ALL (0x5555) | 206 | #define ONENAND_ECC_1BIT_ALL (0x5555) |
193 | #define ONENAND_ECC_2BIT (1 << 1) | 207 | #define ONENAND_ECC_2BIT (1 << 1) |
194 | #define ONENAND_ECC_2BIT_ALL (0xAAAA) | 208 | #define ONENAND_ECC_2BIT_ALL (0xAAAA) |
209 | #define FLEXONENAND_UNCORRECTABLE_ERROR (0x1010) | ||
195 | 210 | ||
196 | /* | 211 | /* |
197 | * One-Time Programmable (OTP) | 212 | * One-Time Programmable (OTP) |
198 | */ | 213 | */ |
214 | #define FLEXONENAND_OTP_LOCK_OFFSET (2048) | ||
199 | #define ONENAND_OTP_LOCK_OFFSET (14) | 215 | #define ONENAND_OTP_LOCK_OFFSET (14) |
200 | 216 | ||
201 | #endif /* __ONENAND_REG_H */ | 217 | #endif /* __ONENAND_REG_H */ |
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h index 7535a74083b9..af6dcb992bc3 100644 --- a/include/linux/mtd/partitions.h +++ b/include/linux/mtd/partitions.h | |||
@@ -40,7 +40,6 @@ struct mtd_partition { | |||
40 | uint64_t offset; /* offset within the master MTD space */ | 40 | uint64_t offset; /* offset within the master MTD space */ |
41 | uint32_t mask_flags; /* master MTD flags to mask out for this partition */ | 41 | uint32_t mask_flags; /* master MTD flags to mask out for this partition */ |
42 | struct nand_ecclayout *ecclayout; /* out of band layout for this partition (NAND only)*/ | 42 | struct nand_ecclayout *ecclayout; /* out of band layout for this partition (NAND only)*/ |
43 | struct mtd_info **mtdp; /* pointer to store the MTD object */ | ||
44 | }; | 43 | }; |
45 | 44 | ||
46 | #define MTDPART_OFS_NXTBLK (-2) | 45 | #define MTDPART_OFS_NXTBLK (-2) |
diff --git a/include/linux/nfs.h b/include/linux/nfs.h index 214d499718f7..f387919bbc59 100644 --- a/include/linux/nfs.h +++ b/include/linux/nfs.h | |||
@@ -25,8 +25,9 @@ | |||
25 | #define NFSMODE_SOCK 0140000 | 25 | #define NFSMODE_SOCK 0140000 |
26 | #define NFSMODE_FIFO 0010000 | 26 | #define NFSMODE_FIFO 0010000 |
27 | 27 | ||
28 | #define NFS_MNT_PROGRAM 100005 | 28 | #define NFS_MNT_PROGRAM 100005 |
29 | #define NFS_MNT_PORT 627 | 29 | #define NFS_MNT_VERSION 1 |
30 | #define NFS_MNT3_VERSION 3 | ||
30 | 31 | ||
31 | /* | 32 | /* |
32 | * NFS stats. The good thing with these values is that NFSv3 errors are | 33 | * NFS stats. The good thing with these values is that NFSv3 errors are |
diff --git a/include/linux/nfs2.h b/include/linux/nfs2.h index 0ed9517138fc..fde24b30cc9e 100644 --- a/include/linux/nfs2.h +++ b/include/linux/nfs2.h | |||
@@ -64,11 +64,4 @@ struct nfs2_fh { | |||
64 | #define NFSPROC_READDIR 16 | 64 | #define NFSPROC_READDIR 16 |
65 | #define NFSPROC_STATFS 17 | 65 | #define NFSPROC_STATFS 17 |
66 | 66 | ||
67 | #define NFS_MNT_PROGRAM 100005 | ||
68 | #define NFS_MNT_VERSION 1 | ||
69 | #define MNTPROC_NULL 0 | ||
70 | #define MNTPROC_MNT 1 | ||
71 | #define MNTPROC_UMNT 3 | ||
72 | #define MNTPROC_UMNTALL 4 | ||
73 | |||
74 | #endif /* _LINUX_NFS2_H */ | 67 | #endif /* _LINUX_NFS2_H */ |
diff --git a/include/linux/nfs3.h b/include/linux/nfs3.h index 539f3b550eab..ac33806ec7f9 100644 --- a/include/linux/nfs3.h +++ b/include/linux/nfs3.h | |||
@@ -88,12 +88,7 @@ struct nfs3_fh { | |||
88 | #define NFS3PROC_PATHCONF 20 | 88 | #define NFS3PROC_PATHCONF 20 |
89 | #define NFS3PROC_COMMIT 21 | 89 | #define NFS3PROC_COMMIT 21 |
90 | 90 | ||
91 | #define NFS_MNT3_PROGRAM 100005 | ||
92 | #define NFS_MNT3_VERSION 3 | 91 | #define NFS_MNT3_VERSION 3 |
93 | #define MOUNTPROC3_NULL 0 | ||
94 | #define MOUNTPROC3_MNT 1 | ||
95 | #define MOUNTPROC3_UMNT 3 | ||
96 | #define MOUNTPROC3_UMNTALL 4 | ||
97 | 92 | ||
98 | 93 | ||
99 | #if defined(__KERNEL__) | 94 | #if defined(__KERNEL__) |
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h index e3f0cbcbd0db..bd2eba530667 100644 --- a/include/linux/nfs4.h +++ b/include/linux/nfs4.h | |||
@@ -21,6 +21,7 @@ | |||
21 | #define NFS4_FHSIZE 128 | 21 | #define NFS4_FHSIZE 128 |
22 | #define NFS4_MAXPATHLEN PATH_MAX | 22 | #define NFS4_MAXPATHLEN PATH_MAX |
23 | #define NFS4_MAXNAMLEN NAME_MAX | 23 | #define NFS4_MAXNAMLEN NAME_MAX |
24 | #define NFS4_OPAQUE_LIMIT 1024 | ||
24 | #define NFS4_MAX_SESSIONID_LEN 16 | 25 | #define NFS4_MAX_SESSIONID_LEN 16 |
25 | 26 | ||
26 | #define NFS4_ACCESS_READ 0x0001 | 27 | #define NFS4_ACCESS_READ 0x0001 |
@@ -130,6 +131,16 @@ | |||
130 | 131 | ||
131 | #define NFS4_MAX_UINT64 (~(u64)0) | 132 | #define NFS4_MAX_UINT64 (~(u64)0) |
132 | 133 | ||
134 | /* An NFS4 sessions server must support at least NFS4_MAX_OPS operations. | ||
135 | * If a compound requires more operations, adjust NFS4_MAX_OPS accordingly. | ||
136 | */ | ||
137 | #define NFS4_MAX_OPS 8 | ||
138 | |||
139 | /* Our NFS4 client back channel server only wants the cb_sequene and the | ||
140 | * actual operation per compound | ||
141 | */ | ||
142 | #define NFS4_MAX_BACK_CHANNEL_OPS 2 | ||
143 | |||
133 | enum nfs4_acl_whotype { | 144 | enum nfs4_acl_whotype { |
134 | NFS4_ACL_WHO_NAMED = 0, | 145 | NFS4_ACL_WHO_NAMED = 0, |
135 | NFS4_ACL_WHO_OWNER, | 146 | NFS4_ACL_WHO_OWNER, |
@@ -462,6 +473,13 @@ enum lock_type4 { | |||
462 | #define NFSPROC4_NULL 0 | 473 | #define NFSPROC4_NULL 0 |
463 | #define NFSPROC4_COMPOUND 1 | 474 | #define NFSPROC4_COMPOUND 1 |
464 | #define NFS4_MINOR_VERSION 0 | 475 | #define NFS4_MINOR_VERSION 0 |
476 | |||
477 | #if defined(CONFIG_NFS_V4_1) | ||
478 | #define NFS4_MAX_MINOR_VERSION 1 | ||
479 | #else | ||
480 | #define NFS4_MAX_MINOR_VERSION 0 | ||
481 | #endif /* CONFIG_NFS_V4_1 */ | ||
482 | |||
465 | #define NFS4_DEBUG 1 | 483 | #define NFS4_DEBUG 1 |
466 | 484 | ||
467 | /* Index of predefined Linux client operations */ | 485 | /* Index of predefined Linux client operations */ |
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h index 6ad75948cbf7..19fe15d12042 100644 --- a/include/linux/nfs_fs_sb.h +++ b/include/linux/nfs_fs_sb.h | |||
@@ -4,11 +4,17 @@ | |||
4 | #include <linux/list.h> | 4 | #include <linux/list.h> |
5 | #include <linux/backing-dev.h> | 5 | #include <linux/backing-dev.h> |
6 | #include <linux/wait.h> | 6 | #include <linux/wait.h> |
7 | #include <linux/nfs_xdr.h> | ||
8 | #include <linux/sunrpc/xprt.h> | ||
7 | 9 | ||
8 | #include <asm/atomic.h> | 10 | #include <asm/atomic.h> |
9 | 11 | ||
12 | struct nfs4_session; | ||
10 | struct nfs_iostats; | 13 | struct nfs_iostats; |
11 | struct nlm_host; | 14 | struct nlm_host; |
15 | struct nfs4_sequence_args; | ||
16 | struct nfs4_sequence_res; | ||
17 | struct nfs_server; | ||
12 | 18 | ||
13 | /* | 19 | /* |
14 | * The nfs_client identifies our client state to the server. | 20 | * The nfs_client identifies our client state to the server. |
@@ -18,6 +24,7 @@ struct nfs_client { | |||
18 | int cl_cons_state; /* current construction state (-ve: init error) */ | 24 | int cl_cons_state; /* current construction state (-ve: init error) */ |
19 | #define NFS_CS_READY 0 /* ready to be used */ | 25 | #define NFS_CS_READY 0 /* ready to be used */ |
20 | #define NFS_CS_INITING 1 /* busy initialising */ | 26 | #define NFS_CS_INITING 1 /* busy initialising */ |
27 | #define NFS_CS_SESSION_INITING 2 /* busy initialising session */ | ||
21 | unsigned long cl_res_state; /* NFS resources state */ | 28 | unsigned long cl_res_state; /* NFS resources state */ |
22 | #define NFS_CS_CALLBACK 1 /* - callback started */ | 29 | #define NFS_CS_CALLBACK 1 /* - callback started */ |
23 | #define NFS_CS_IDMAP 2 /* - idmap started */ | 30 | #define NFS_CS_IDMAP 2 /* - idmap started */ |
@@ -32,6 +39,7 @@ struct nfs_client { | |||
32 | const struct nfs_rpc_ops *rpc_ops; /* NFS protocol vector */ | 39 | const struct nfs_rpc_ops *rpc_ops; /* NFS protocol vector */ |
33 | int cl_proto; /* Network transport protocol */ | 40 | int cl_proto; /* Network transport protocol */ |
34 | 41 | ||
42 | u32 cl_minorversion;/* NFSv4 minorversion */ | ||
35 | struct rpc_cred *cl_machine_cred; | 43 | struct rpc_cred *cl_machine_cred; |
36 | 44 | ||
37 | #ifdef CONFIG_NFS_V4 | 45 | #ifdef CONFIG_NFS_V4 |
@@ -63,7 +71,22 @@ struct nfs_client { | |||
63 | */ | 71 | */ |
64 | char cl_ipaddr[48]; | 72 | char cl_ipaddr[48]; |
65 | unsigned char cl_id_uniquifier; | 73 | unsigned char cl_id_uniquifier; |
66 | #endif | 74 | int (* cl_call_sync)(struct nfs_server *server, |
75 | struct rpc_message *msg, | ||
76 | struct nfs4_sequence_args *args, | ||
77 | struct nfs4_sequence_res *res, | ||
78 | int cache_reply); | ||
79 | #endif /* CONFIG_NFS_V4 */ | ||
80 | |||
81 | #ifdef CONFIG_NFS_V4_1 | ||
82 | /* clientid returned from EXCHANGE_ID, used by session operations */ | ||
83 | u64 cl_ex_clid; | ||
84 | /* The sequence id to use for the next CREATE_SESSION */ | ||
85 | u32 cl_seqid; | ||
86 | /* The flags used for obtaining the clientid during EXCHANGE_ID */ | ||
87 | u32 cl_exchange_flags; | ||
88 | struct nfs4_session *cl_session; /* sharred session */ | ||
89 | #endif /* CONFIG_NFS_V4_1 */ | ||
67 | 90 | ||
68 | #ifdef CONFIG_NFS_FSCACHE | 91 | #ifdef CONFIG_NFS_FSCACHE |
69 | struct fscache_cookie *fscache; /* client index cache cookie */ | 92 | struct fscache_cookie *fscache; /* client index cache cookie */ |
@@ -145,4 +168,46 @@ struct nfs_server { | |||
145 | #define NFS_CAP_ACLS (1U << 3) | 168 | #define NFS_CAP_ACLS (1U << 3) |
146 | #define NFS_CAP_ATOMIC_OPEN (1U << 4) | 169 | #define NFS_CAP_ATOMIC_OPEN (1U << 4) |
147 | 170 | ||
171 | |||
172 | /* maximum number of slots to use */ | ||
173 | #define NFS4_MAX_SLOT_TABLE RPC_MAX_SLOT_TABLE | ||
174 | |||
175 | #if defined(CONFIG_NFS_V4_1) | ||
176 | |||
177 | /* Sessions */ | ||
178 | #define SLOT_TABLE_SZ (NFS4_MAX_SLOT_TABLE/(8*sizeof(long))) | ||
179 | struct nfs4_slot_table { | ||
180 | struct nfs4_slot *slots; /* seqid per slot */ | ||
181 | unsigned long used_slots[SLOT_TABLE_SZ]; /* used/unused bitmap */ | ||
182 | spinlock_t slot_tbl_lock; | ||
183 | struct rpc_wait_queue slot_tbl_waitq; /* allocators may wait here */ | ||
184 | int max_slots; /* # slots in table */ | ||
185 | int highest_used_slotid; /* sent to server on each SEQ. | ||
186 | * op for dynamic resizing */ | ||
187 | }; | ||
188 | |||
189 | static inline int slot_idx(struct nfs4_slot_table *tbl, struct nfs4_slot *sp) | ||
190 | { | ||
191 | return sp - tbl->slots; | ||
192 | } | ||
193 | |||
194 | /* | ||
195 | * Session related parameters | ||
196 | */ | ||
197 | struct nfs4_session { | ||
198 | struct nfs4_sessionid sess_id; | ||
199 | u32 flags; | ||
200 | unsigned long session_state; | ||
201 | u32 hash_alg; | ||
202 | u32 ssv_len; | ||
203 | |||
204 | /* The fore and back channel */ | ||
205 | struct nfs4_channel_attrs fc_attrs; | ||
206 | struct nfs4_slot_table fc_slot_table; | ||
207 | struct nfs4_channel_attrs bc_attrs; | ||
208 | struct nfs4_slot_table bc_slot_table; | ||
209 | struct nfs_client *clp; | ||
210 | }; | ||
211 | |||
212 | #endif /* CONFIG_NFS_V4_1 */ | ||
148 | #endif | 213 | #endif |
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h index b89c34e40bc2..62f63fb0c4c8 100644 --- a/include/linux/nfs_xdr.h +++ b/include/linux/nfs_xdr.h | |||
@@ -145,6 +145,44 @@ struct nfs4_change_info { | |||
145 | }; | 145 | }; |
146 | 146 | ||
147 | struct nfs_seqid; | 147 | struct nfs_seqid; |
148 | |||
149 | /* nfs41 sessions channel attributes */ | ||
150 | struct nfs4_channel_attrs { | ||
151 | u32 headerpadsz; | ||
152 | u32 max_rqst_sz; | ||
153 | u32 max_resp_sz; | ||
154 | u32 max_resp_sz_cached; | ||
155 | u32 max_ops; | ||
156 | u32 max_reqs; | ||
157 | }; | ||
158 | |||
159 | /* nfs41 sessions slot seqid */ | ||
160 | struct nfs4_slot { | ||
161 | u32 seq_nr; | ||
162 | }; | ||
163 | |||
164 | struct nfs4_sequence_args { | ||
165 | struct nfs4_session *sa_session; | ||
166 | u8 sa_slotid; | ||
167 | u8 sa_cache_this; | ||
168 | }; | ||
169 | |||
170 | struct nfs4_sequence_res { | ||
171 | struct nfs4_session *sr_session; | ||
172 | u8 sr_slotid; /* slot used to send request */ | ||
173 | unsigned long sr_renewal_time; | ||
174 | int sr_status; /* sequence operation status */ | ||
175 | }; | ||
176 | |||
177 | struct nfs4_get_lease_time_args { | ||
178 | struct nfs4_sequence_args la_seq_args; | ||
179 | }; | ||
180 | |||
181 | struct nfs4_get_lease_time_res { | ||
182 | struct nfs_fsinfo *lr_fsinfo; | ||
183 | struct nfs4_sequence_res lr_seq_res; | ||
184 | }; | ||
185 | |||
148 | /* | 186 | /* |
149 | * Arguments to the open call. | 187 | * Arguments to the open call. |
150 | */ | 188 | */ |
@@ -165,6 +203,7 @@ struct nfs_openargs { | |||
165 | const struct nfs_server *server; /* Needed for ID mapping */ | 203 | const struct nfs_server *server; /* Needed for ID mapping */ |
166 | const u32 * bitmask; | 204 | const u32 * bitmask; |
167 | __u32 claim; | 205 | __u32 claim; |
206 | struct nfs4_sequence_args seq_args; | ||
168 | }; | 207 | }; |
169 | 208 | ||
170 | struct nfs_openres { | 209 | struct nfs_openres { |
@@ -181,6 +220,7 @@ struct nfs_openres { | |||
181 | __u32 do_recall; | 220 | __u32 do_recall; |
182 | __u64 maxsize; | 221 | __u64 maxsize; |
183 | __u32 attrset[NFS4_BITMAP_SIZE]; | 222 | __u32 attrset[NFS4_BITMAP_SIZE]; |
223 | struct nfs4_sequence_res seq_res; | ||
184 | }; | 224 | }; |
185 | 225 | ||
186 | /* | 226 | /* |
@@ -206,6 +246,7 @@ struct nfs_closeargs { | |||
206 | struct nfs_seqid * seqid; | 246 | struct nfs_seqid * seqid; |
207 | fmode_t fmode; | 247 | fmode_t fmode; |
208 | const u32 * bitmask; | 248 | const u32 * bitmask; |
249 | struct nfs4_sequence_args seq_args; | ||
209 | }; | 250 | }; |
210 | 251 | ||
211 | struct nfs_closeres { | 252 | struct nfs_closeres { |
@@ -213,6 +254,7 @@ struct nfs_closeres { | |||
213 | struct nfs_fattr * fattr; | 254 | struct nfs_fattr * fattr; |
214 | struct nfs_seqid * seqid; | 255 | struct nfs_seqid * seqid; |
215 | const struct nfs_server *server; | 256 | const struct nfs_server *server; |
257 | struct nfs4_sequence_res seq_res; | ||
216 | }; | 258 | }; |
217 | /* | 259 | /* |
218 | * * Arguments to the lock,lockt, and locku call. | 260 | * * Arguments to the lock,lockt, and locku call. |
@@ -233,12 +275,14 @@ struct nfs_lock_args { | |||
233 | unsigned char block : 1; | 275 | unsigned char block : 1; |
234 | unsigned char reclaim : 1; | 276 | unsigned char reclaim : 1; |
235 | unsigned char new_lock_owner : 1; | 277 | unsigned char new_lock_owner : 1; |
278 | struct nfs4_sequence_args seq_args; | ||
236 | }; | 279 | }; |
237 | 280 | ||
238 | struct nfs_lock_res { | 281 | struct nfs_lock_res { |
239 | nfs4_stateid stateid; | 282 | nfs4_stateid stateid; |
240 | struct nfs_seqid * lock_seqid; | 283 | struct nfs_seqid * lock_seqid; |
241 | struct nfs_seqid * open_seqid; | 284 | struct nfs_seqid * open_seqid; |
285 | struct nfs4_sequence_res seq_res; | ||
242 | }; | 286 | }; |
243 | 287 | ||
244 | struct nfs_locku_args { | 288 | struct nfs_locku_args { |
@@ -246,32 +290,38 @@ struct nfs_locku_args { | |||
246 | struct file_lock * fl; | 290 | struct file_lock * fl; |
247 | struct nfs_seqid * seqid; | 291 | struct nfs_seqid * seqid; |
248 | nfs4_stateid * stateid; | 292 | nfs4_stateid * stateid; |
293 | struct nfs4_sequence_args seq_args; | ||
249 | }; | 294 | }; |
250 | 295 | ||
251 | struct nfs_locku_res { | 296 | struct nfs_locku_res { |
252 | nfs4_stateid stateid; | 297 | nfs4_stateid stateid; |
253 | struct nfs_seqid * seqid; | 298 | struct nfs_seqid * seqid; |
299 | struct nfs4_sequence_res seq_res; | ||
254 | }; | 300 | }; |
255 | 301 | ||
256 | struct nfs_lockt_args { | 302 | struct nfs_lockt_args { |
257 | struct nfs_fh * fh; | 303 | struct nfs_fh * fh; |
258 | struct file_lock * fl; | 304 | struct file_lock * fl; |
259 | struct nfs_lowner lock_owner; | 305 | struct nfs_lowner lock_owner; |
306 | struct nfs4_sequence_args seq_args; | ||
260 | }; | 307 | }; |
261 | 308 | ||
262 | struct nfs_lockt_res { | 309 | struct nfs_lockt_res { |
263 | struct file_lock * denied; /* LOCK, LOCKT failed */ | 310 | struct file_lock * denied; /* LOCK, LOCKT failed */ |
311 | struct nfs4_sequence_res seq_res; | ||
264 | }; | 312 | }; |
265 | 313 | ||
266 | struct nfs4_delegreturnargs { | 314 | struct nfs4_delegreturnargs { |
267 | const struct nfs_fh *fhandle; | 315 | const struct nfs_fh *fhandle; |
268 | const nfs4_stateid *stateid; | 316 | const nfs4_stateid *stateid; |
269 | const u32 * bitmask; | 317 | const u32 * bitmask; |
318 | struct nfs4_sequence_args seq_args; | ||
270 | }; | 319 | }; |
271 | 320 | ||
272 | struct nfs4_delegreturnres { | 321 | struct nfs4_delegreturnres { |
273 | struct nfs_fattr * fattr; | 322 | struct nfs_fattr * fattr; |
274 | const struct nfs_server *server; | 323 | const struct nfs_server *server; |
324 | struct nfs4_sequence_res seq_res; | ||
275 | }; | 325 | }; |
276 | 326 | ||
277 | /* | 327 | /* |
@@ -284,12 +334,14 @@ struct nfs_readargs { | |||
284 | __u32 count; | 334 | __u32 count; |
285 | unsigned int pgbase; | 335 | unsigned int pgbase; |
286 | struct page ** pages; | 336 | struct page ** pages; |
337 | struct nfs4_sequence_args seq_args; | ||
287 | }; | 338 | }; |
288 | 339 | ||
289 | struct nfs_readres { | 340 | struct nfs_readres { |
290 | struct nfs_fattr * fattr; | 341 | struct nfs_fattr * fattr; |
291 | __u32 count; | 342 | __u32 count; |
292 | int eof; | 343 | int eof; |
344 | struct nfs4_sequence_res seq_res; | ||
293 | }; | 345 | }; |
294 | 346 | ||
295 | /* | 347 | /* |
@@ -304,6 +356,7 @@ struct nfs_writeargs { | |||
304 | unsigned int pgbase; | 356 | unsigned int pgbase; |
305 | struct page ** pages; | 357 | struct page ** pages; |
306 | const u32 * bitmask; | 358 | const u32 * bitmask; |
359 | struct nfs4_sequence_args seq_args; | ||
307 | }; | 360 | }; |
308 | 361 | ||
309 | struct nfs_writeverf { | 362 | struct nfs_writeverf { |
@@ -316,6 +369,7 @@ struct nfs_writeres { | |||
316 | struct nfs_writeverf * verf; | 369 | struct nfs_writeverf * verf; |
317 | __u32 count; | 370 | __u32 count; |
318 | const struct nfs_server *server; | 371 | const struct nfs_server *server; |
372 | struct nfs4_sequence_res seq_res; | ||
319 | }; | 373 | }; |
320 | 374 | ||
321 | /* | 375 | /* |
@@ -325,12 +379,14 @@ struct nfs_removeargs { | |||
325 | const struct nfs_fh *fh; | 379 | const struct nfs_fh *fh; |
326 | struct qstr name; | 380 | struct qstr name; |
327 | const u32 * bitmask; | 381 | const u32 * bitmask; |
382 | struct nfs4_sequence_args seq_args; | ||
328 | }; | 383 | }; |
329 | 384 | ||
330 | struct nfs_removeres { | 385 | struct nfs_removeres { |
331 | const struct nfs_server *server; | 386 | const struct nfs_server *server; |
332 | struct nfs4_change_info cinfo; | 387 | struct nfs4_change_info cinfo; |
333 | struct nfs_fattr dir_attr; | 388 | struct nfs_fattr dir_attr; |
389 | struct nfs4_sequence_res seq_res; | ||
334 | }; | 390 | }; |
335 | 391 | ||
336 | /* | 392 | /* |
@@ -383,6 +439,7 @@ struct nfs_setattrargs { | |||
383 | struct iattr * iap; | 439 | struct iattr * iap; |
384 | const struct nfs_server * server; /* Needed for name mapping */ | 440 | const struct nfs_server * server; /* Needed for name mapping */ |
385 | const u32 * bitmask; | 441 | const u32 * bitmask; |
442 | struct nfs4_sequence_args seq_args; | ||
386 | }; | 443 | }; |
387 | 444 | ||
388 | struct nfs_setaclargs { | 445 | struct nfs_setaclargs { |
@@ -390,6 +447,11 @@ struct nfs_setaclargs { | |||
390 | size_t acl_len; | 447 | size_t acl_len; |
391 | unsigned int acl_pgbase; | 448 | unsigned int acl_pgbase; |
392 | struct page ** acl_pages; | 449 | struct page ** acl_pages; |
450 | struct nfs4_sequence_args seq_args; | ||
451 | }; | ||
452 | |||
453 | struct nfs_setaclres { | ||
454 | struct nfs4_sequence_res seq_res; | ||
393 | }; | 455 | }; |
394 | 456 | ||
395 | struct nfs_getaclargs { | 457 | struct nfs_getaclargs { |
@@ -397,11 +459,18 @@ struct nfs_getaclargs { | |||
397 | size_t acl_len; | 459 | size_t acl_len; |
398 | unsigned int acl_pgbase; | 460 | unsigned int acl_pgbase; |
399 | struct page ** acl_pages; | 461 | struct page ** acl_pages; |
462 | struct nfs4_sequence_args seq_args; | ||
463 | }; | ||
464 | |||
465 | struct nfs_getaclres { | ||
466 | size_t acl_len; | ||
467 | struct nfs4_sequence_res seq_res; | ||
400 | }; | 468 | }; |
401 | 469 | ||
402 | struct nfs_setattrres { | 470 | struct nfs_setattrres { |
403 | struct nfs_fattr * fattr; | 471 | struct nfs_fattr * fattr; |
404 | const struct nfs_server * server; | 472 | const struct nfs_server * server; |
473 | struct nfs4_sequence_res seq_res; | ||
405 | }; | 474 | }; |
406 | 475 | ||
407 | struct nfs_linkargs { | 476 | struct nfs_linkargs { |
@@ -583,6 +652,7 @@ struct nfs4_accessargs { | |||
583 | const struct nfs_fh * fh; | 652 | const struct nfs_fh * fh; |
584 | const u32 * bitmask; | 653 | const u32 * bitmask; |
585 | u32 access; | 654 | u32 access; |
655 | struct nfs4_sequence_args seq_args; | ||
586 | }; | 656 | }; |
587 | 657 | ||
588 | struct nfs4_accessres { | 658 | struct nfs4_accessres { |
@@ -590,6 +660,7 @@ struct nfs4_accessres { | |||
590 | struct nfs_fattr * fattr; | 660 | struct nfs_fattr * fattr; |
591 | u32 supported; | 661 | u32 supported; |
592 | u32 access; | 662 | u32 access; |
663 | struct nfs4_sequence_res seq_res; | ||
593 | }; | 664 | }; |
594 | 665 | ||
595 | struct nfs4_create_arg { | 666 | struct nfs4_create_arg { |
@@ -609,6 +680,7 @@ struct nfs4_create_arg { | |||
609 | const struct iattr * attrs; | 680 | const struct iattr * attrs; |
610 | const struct nfs_fh * dir_fh; | 681 | const struct nfs_fh * dir_fh; |
611 | const u32 * bitmask; | 682 | const u32 * bitmask; |
683 | struct nfs4_sequence_args seq_args; | ||
612 | }; | 684 | }; |
613 | 685 | ||
614 | struct nfs4_create_res { | 686 | struct nfs4_create_res { |
@@ -617,21 +689,30 @@ struct nfs4_create_res { | |||
617 | struct nfs_fattr * fattr; | 689 | struct nfs_fattr * fattr; |
618 | struct nfs4_change_info dir_cinfo; | 690 | struct nfs4_change_info dir_cinfo; |
619 | struct nfs_fattr * dir_fattr; | 691 | struct nfs_fattr * dir_fattr; |
692 | struct nfs4_sequence_res seq_res; | ||
620 | }; | 693 | }; |
621 | 694 | ||
622 | struct nfs4_fsinfo_arg { | 695 | struct nfs4_fsinfo_arg { |
623 | const struct nfs_fh * fh; | 696 | const struct nfs_fh * fh; |
624 | const u32 * bitmask; | 697 | const u32 * bitmask; |
698 | struct nfs4_sequence_args seq_args; | ||
699 | }; | ||
700 | |||
701 | struct nfs4_fsinfo_res { | ||
702 | struct nfs_fsinfo *fsinfo; | ||
703 | struct nfs4_sequence_res seq_res; | ||
625 | }; | 704 | }; |
626 | 705 | ||
627 | struct nfs4_getattr_arg { | 706 | struct nfs4_getattr_arg { |
628 | const struct nfs_fh * fh; | 707 | const struct nfs_fh * fh; |
629 | const u32 * bitmask; | 708 | const u32 * bitmask; |
709 | struct nfs4_sequence_args seq_args; | ||
630 | }; | 710 | }; |
631 | 711 | ||
632 | struct nfs4_getattr_res { | 712 | struct nfs4_getattr_res { |
633 | const struct nfs_server * server; | 713 | const struct nfs_server * server; |
634 | struct nfs_fattr * fattr; | 714 | struct nfs_fattr * fattr; |
715 | struct nfs4_sequence_res seq_res; | ||
635 | }; | 716 | }; |
636 | 717 | ||
637 | struct nfs4_link_arg { | 718 | struct nfs4_link_arg { |
@@ -639,6 +720,7 @@ struct nfs4_link_arg { | |||
639 | const struct nfs_fh * dir_fh; | 720 | const struct nfs_fh * dir_fh; |
640 | const struct qstr * name; | 721 | const struct qstr * name; |
641 | const u32 * bitmask; | 722 | const u32 * bitmask; |
723 | struct nfs4_sequence_args seq_args; | ||
642 | }; | 724 | }; |
643 | 725 | ||
644 | struct nfs4_link_res { | 726 | struct nfs4_link_res { |
@@ -646,6 +728,7 @@ struct nfs4_link_res { | |||
646 | struct nfs_fattr * fattr; | 728 | struct nfs_fattr * fattr; |
647 | struct nfs4_change_info cinfo; | 729 | struct nfs4_change_info cinfo; |
648 | struct nfs_fattr * dir_attr; | 730 | struct nfs_fattr * dir_attr; |
731 | struct nfs4_sequence_res seq_res; | ||
649 | }; | 732 | }; |
650 | 733 | ||
651 | 734 | ||
@@ -653,21 +736,30 @@ struct nfs4_lookup_arg { | |||
653 | const struct nfs_fh * dir_fh; | 736 | const struct nfs_fh * dir_fh; |
654 | const struct qstr * name; | 737 | const struct qstr * name; |
655 | const u32 * bitmask; | 738 | const u32 * bitmask; |
739 | struct nfs4_sequence_args seq_args; | ||
656 | }; | 740 | }; |
657 | 741 | ||
658 | struct nfs4_lookup_res { | 742 | struct nfs4_lookup_res { |
659 | const struct nfs_server * server; | 743 | const struct nfs_server * server; |
660 | struct nfs_fattr * fattr; | 744 | struct nfs_fattr * fattr; |
661 | struct nfs_fh * fh; | 745 | struct nfs_fh * fh; |
746 | struct nfs4_sequence_res seq_res; | ||
662 | }; | 747 | }; |
663 | 748 | ||
664 | struct nfs4_lookup_root_arg { | 749 | struct nfs4_lookup_root_arg { |
665 | const u32 * bitmask; | 750 | const u32 * bitmask; |
751 | struct nfs4_sequence_args seq_args; | ||
666 | }; | 752 | }; |
667 | 753 | ||
668 | struct nfs4_pathconf_arg { | 754 | struct nfs4_pathconf_arg { |
669 | const struct nfs_fh * fh; | 755 | const struct nfs_fh * fh; |
670 | const u32 * bitmask; | 756 | const u32 * bitmask; |
757 | struct nfs4_sequence_args seq_args; | ||
758 | }; | ||
759 | |||
760 | struct nfs4_pathconf_res { | ||
761 | struct nfs_pathconf *pathconf; | ||
762 | struct nfs4_sequence_res seq_res; | ||
671 | }; | 763 | }; |
672 | 764 | ||
673 | struct nfs4_readdir_arg { | 765 | struct nfs4_readdir_arg { |
@@ -678,11 +770,13 @@ struct nfs4_readdir_arg { | |||
678 | struct page ** pages; /* zero-copy data */ | 770 | struct page ** pages; /* zero-copy data */ |
679 | unsigned int pgbase; /* zero-copy data */ | 771 | unsigned int pgbase; /* zero-copy data */ |
680 | const u32 * bitmask; | 772 | const u32 * bitmask; |
773 | struct nfs4_sequence_args seq_args; | ||
681 | }; | 774 | }; |
682 | 775 | ||
683 | struct nfs4_readdir_res { | 776 | struct nfs4_readdir_res { |
684 | nfs4_verifier verifier; | 777 | nfs4_verifier verifier; |
685 | unsigned int pgbase; | 778 | unsigned int pgbase; |
779 | struct nfs4_sequence_res seq_res; | ||
686 | }; | 780 | }; |
687 | 781 | ||
688 | struct nfs4_readlink { | 782 | struct nfs4_readlink { |
@@ -690,6 +784,11 @@ struct nfs4_readlink { | |||
690 | unsigned int pgbase; | 784 | unsigned int pgbase; |
691 | unsigned int pglen; /* zero-copy data */ | 785 | unsigned int pglen; /* zero-copy data */ |
692 | struct page ** pages; /* zero-copy data */ | 786 | struct page ** pages; /* zero-copy data */ |
787 | struct nfs4_sequence_args seq_args; | ||
788 | }; | ||
789 | |||
790 | struct nfs4_readlink_res { | ||
791 | struct nfs4_sequence_res seq_res; | ||
693 | }; | 792 | }; |
694 | 793 | ||
695 | struct nfs4_rename_arg { | 794 | struct nfs4_rename_arg { |
@@ -698,6 +797,7 @@ struct nfs4_rename_arg { | |||
698 | const struct qstr * old_name; | 797 | const struct qstr * old_name; |
699 | const struct qstr * new_name; | 798 | const struct qstr * new_name; |
700 | const u32 * bitmask; | 799 | const u32 * bitmask; |
800 | struct nfs4_sequence_args seq_args; | ||
701 | }; | 801 | }; |
702 | 802 | ||
703 | struct nfs4_rename_res { | 803 | struct nfs4_rename_res { |
@@ -706,6 +806,7 @@ struct nfs4_rename_res { | |||
706 | struct nfs_fattr * old_fattr; | 806 | struct nfs_fattr * old_fattr; |
707 | struct nfs4_change_info new_cinfo; | 807 | struct nfs4_change_info new_cinfo; |
708 | struct nfs_fattr * new_fattr; | 808 | struct nfs_fattr * new_fattr; |
809 | struct nfs4_sequence_res seq_res; | ||
709 | }; | 810 | }; |
710 | 811 | ||
711 | #define NFS4_SETCLIENTID_NAMELEN (127) | 812 | #define NFS4_SETCLIENTID_NAMELEN (127) |
@@ -724,6 +825,17 @@ struct nfs4_setclientid { | |||
724 | struct nfs4_statfs_arg { | 825 | struct nfs4_statfs_arg { |
725 | const struct nfs_fh * fh; | 826 | const struct nfs_fh * fh; |
726 | const u32 * bitmask; | 827 | const u32 * bitmask; |
828 | struct nfs4_sequence_args seq_args; | ||
829 | }; | ||
830 | |||
831 | struct nfs4_statfs_res { | ||
832 | struct nfs_fsstat *fsstat; | ||
833 | struct nfs4_sequence_res seq_res; | ||
834 | }; | ||
835 | |||
836 | struct nfs4_server_caps_arg { | ||
837 | struct nfs_fh *fhandle; | ||
838 | struct nfs4_sequence_args seq_args; | ||
727 | }; | 839 | }; |
728 | 840 | ||
729 | struct nfs4_server_caps_res { | 841 | struct nfs4_server_caps_res { |
@@ -731,6 +843,7 @@ struct nfs4_server_caps_res { | |||
731 | u32 acl_bitmask; | 843 | u32 acl_bitmask; |
732 | u32 has_links; | 844 | u32 has_links; |
733 | u32 has_symlinks; | 845 | u32 has_symlinks; |
846 | struct nfs4_sequence_res seq_res; | ||
734 | }; | 847 | }; |
735 | 848 | ||
736 | struct nfs4_string { | 849 | struct nfs4_string { |
@@ -765,10 +878,68 @@ struct nfs4_fs_locations_arg { | |||
765 | const struct qstr *name; | 878 | const struct qstr *name; |
766 | struct page *page; | 879 | struct page *page; |
767 | const u32 *bitmask; | 880 | const u32 *bitmask; |
881 | struct nfs4_sequence_args seq_args; | ||
882 | }; | ||
883 | |||
884 | struct nfs4_fs_locations_res { | ||
885 | struct nfs4_fs_locations *fs_locations; | ||
886 | struct nfs4_sequence_res seq_res; | ||
768 | }; | 887 | }; |
769 | 888 | ||
770 | #endif /* CONFIG_NFS_V4 */ | 889 | #endif /* CONFIG_NFS_V4 */ |
771 | 890 | ||
891 | struct nfstime4 { | ||
892 | u64 seconds; | ||
893 | u32 nseconds; | ||
894 | }; | ||
895 | |||
896 | #ifdef CONFIG_NFS_V4_1 | ||
897 | struct nfs_impl_id4 { | ||
898 | u32 domain_len; | ||
899 | char *domain; | ||
900 | u32 name_len; | ||
901 | char *name; | ||
902 | struct nfstime4 date; | ||
903 | }; | ||
904 | |||
905 | #define NFS4_EXCHANGE_ID_LEN (48) | ||
906 | struct nfs41_exchange_id_args { | ||
907 | struct nfs_client *client; | ||
908 | nfs4_verifier *verifier; | ||
909 | unsigned int id_len; | ||
910 | char id[NFS4_EXCHANGE_ID_LEN]; | ||
911 | u32 flags; | ||
912 | }; | ||
913 | |||
914 | struct server_owner { | ||
915 | uint64_t minor_id; | ||
916 | uint32_t major_id_sz; | ||
917 | char major_id[NFS4_OPAQUE_LIMIT]; | ||
918 | }; | ||
919 | |||
920 | struct server_scope { | ||
921 | uint32_t server_scope_sz; | ||
922 | char server_scope[NFS4_OPAQUE_LIMIT]; | ||
923 | }; | ||
924 | |||
925 | struct nfs41_exchange_id_res { | ||
926 | struct nfs_client *client; | ||
927 | u32 flags; | ||
928 | }; | ||
929 | |||
930 | struct nfs41_create_session_args { | ||
931 | struct nfs_client *client; | ||
932 | uint32_t flags; | ||
933 | uint32_t cb_program; | ||
934 | struct nfs4_channel_attrs fc_attrs; /* Fore Channel */ | ||
935 | struct nfs4_channel_attrs bc_attrs; /* Back Channel */ | ||
936 | }; | ||
937 | |||
938 | struct nfs41_create_session_res { | ||
939 | struct nfs_client *client; | ||
940 | }; | ||
941 | #endif /* CONFIG_NFS_V4_1 */ | ||
942 | |||
772 | struct nfs_page; | 943 | struct nfs_page; |
773 | 944 | ||
774 | #define NFS_PAGEVEC_SIZE (8U) | 945 | #define NFS_PAGEVEC_SIZE (8U) |
diff --git a/include/linux/nfsd/cache.h b/include/linux/nfsd/cache.h index 5bccaab81056..3a3f58934f5e 100644 --- a/include/linux/nfsd/cache.h +++ b/include/linux/nfsd/cache.h | |||
@@ -14,8 +14,7 @@ | |||
14 | #include <linux/uio.h> | 14 | #include <linux/uio.h> |
15 | 15 | ||
16 | /* | 16 | /* |
17 | * Representation of a reply cache entry. The first two members *must* | 17 | * Representation of a reply cache entry. |
18 | * be hash_next and hash_prev. | ||
19 | */ | 18 | */ |
20 | struct svc_cacherep { | 19 | struct svc_cacherep { |
21 | struct hlist_node c_hash; | 20 | struct hlist_node c_hash; |
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h index afa19016c4a8..8f641c908450 100644 --- a/include/linux/nfsd/nfsfh.h +++ b/include/linux/nfsd/nfsfh.h | |||
@@ -151,9 +151,15 @@ typedef struct svc_fh { | |||
151 | __u64 fh_pre_size; /* size before operation */ | 151 | __u64 fh_pre_size; /* size before operation */ |
152 | struct timespec fh_pre_mtime; /* mtime before oper */ | 152 | struct timespec fh_pre_mtime; /* mtime before oper */ |
153 | struct timespec fh_pre_ctime; /* ctime before oper */ | 153 | struct timespec fh_pre_ctime; /* ctime before oper */ |
154 | /* | ||
155 | * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode) | ||
156 | * to find out if it is valid. | ||
157 | */ | ||
158 | u64 fh_pre_change; | ||
154 | 159 | ||
155 | /* Post-op attributes saved in fh_unlock */ | 160 | /* Post-op attributes saved in fh_unlock */ |
156 | struct kstat fh_post_attr; /* full attrs after operation */ | 161 | struct kstat fh_post_attr; /* full attrs after operation */ |
162 | u64 fh_post_change; /* nfsv4 change; see above */ | ||
157 | #endif /* CONFIG_NFSD_V3 */ | 163 | #endif /* CONFIG_NFSD_V3 */ |
158 | 164 | ||
159 | } svc_fh; | 165 | } svc_fh; |
@@ -298,6 +304,7 @@ fill_pre_wcc(struct svc_fh *fhp) | |||
298 | fhp->fh_pre_mtime = inode->i_mtime; | 304 | fhp->fh_pre_mtime = inode->i_mtime; |
299 | fhp->fh_pre_ctime = inode->i_ctime; | 305 | fhp->fh_pre_ctime = inode->i_ctime; |
300 | fhp->fh_pre_size = inode->i_size; | 306 | fhp->fh_pre_size = inode->i_size; |
307 | fhp->fh_pre_change = inode->i_version; | ||
301 | fhp->fh_pre_saved = 1; | 308 | fhp->fh_pre_saved = 1; |
302 | } | 309 | } |
303 | } | 310 | } |
diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h index 4d61c873feed..57ab2ed08459 100644 --- a/include/linux/nfsd/state.h +++ b/include/linux/nfsd/state.h | |||
@@ -41,7 +41,6 @@ | |||
41 | #include <linux/kref.h> | 41 | #include <linux/kref.h> |
42 | #include <linux/sunrpc/clnt.h> | 42 | #include <linux/sunrpc/clnt.h> |
43 | 43 | ||
44 | #define NFS4_OPAQUE_LIMIT 1024 | ||
45 | typedef struct { | 44 | typedef struct { |
46 | u32 cl_boot; | 45 | u32 cl_boot; |
47 | u32 cl_id; | 46 | u32 cl_id; |
@@ -61,15 +60,6 @@ typedef struct { | |||
61 | #define si_stateownerid si_opaque.so_stateownerid | 60 | #define si_stateownerid si_opaque.so_stateownerid |
62 | #define si_fileid si_opaque.so_fileid | 61 | #define si_fileid si_opaque.so_fileid |
63 | 62 | ||
64 | |||
65 | struct nfs4_cb_recall { | ||
66 | u32 cbr_ident; | ||
67 | int cbr_trunc; | ||
68 | stateid_t cbr_stateid; | ||
69 | struct knfsd_fh cbr_fh; | ||
70 | struct nfs4_delegation *cbr_dp; | ||
71 | }; | ||
72 | |||
73 | struct nfs4_delegation { | 63 | struct nfs4_delegation { |
74 | struct list_head dl_perfile; | 64 | struct list_head dl_perfile; |
75 | struct list_head dl_perclnt; | 65 | struct list_head dl_perclnt; |
@@ -81,22 +71,25 @@ struct nfs4_delegation { | |||
81 | struct file *dl_vfs_file; | 71 | struct file *dl_vfs_file; |
82 | u32 dl_type; | 72 | u32 dl_type; |
83 | time_t dl_time; | 73 | time_t dl_time; |
84 | struct nfs4_cb_recall dl_recall; | 74 | /* For recall: */ |
75 | u32 dl_ident; | ||
76 | stateid_t dl_stateid; | ||
77 | struct knfsd_fh dl_fh; | ||
78 | int dl_retries; | ||
85 | }; | 79 | }; |
86 | 80 | ||
87 | #define dl_stateid dl_recall.cbr_stateid | ||
88 | #define dl_fh dl_recall.cbr_fh | ||
89 | |||
90 | /* client delegation callback info */ | 81 | /* client delegation callback info */ |
91 | struct nfs4_callback { | 82 | struct nfs4_cb_conn { |
92 | /* SETCLIENTID info */ | 83 | /* SETCLIENTID info */ |
93 | u32 cb_addr; | 84 | u32 cb_addr; |
94 | unsigned short cb_port; | 85 | unsigned short cb_port; |
95 | u32 cb_prog; | 86 | u32 cb_prog; |
96 | u32 cb_ident; | 87 | u32 cb_minorversion; |
88 | u32 cb_ident; /* minorversion 0 only */ | ||
97 | /* RPC client info */ | 89 | /* RPC client info */ |
98 | atomic_t cb_set; /* successful CB_NULL call */ | 90 | atomic_t cb_set; /* successful CB_NULL call */ |
99 | struct rpc_clnt * cb_client; | 91 | struct rpc_clnt * cb_client; |
92 | struct rpc_cred * cb_cred; | ||
100 | }; | 93 | }; |
101 | 94 | ||
102 | /* Maximum number of slots per session. 128 is useful for long haul TCP */ | 95 | /* Maximum number of slots per session. 128 is useful for long haul TCP */ |
@@ -122,6 +115,17 @@ struct nfsd4_slot { | |||
122 | struct nfsd4_cache_entry sl_cache_entry; | 115 | struct nfsd4_cache_entry sl_cache_entry; |
123 | }; | 116 | }; |
124 | 117 | ||
118 | struct nfsd4_channel_attrs { | ||
119 | u32 headerpadsz; | ||
120 | u32 maxreq_sz; | ||
121 | u32 maxresp_sz; | ||
122 | u32 maxresp_cached; | ||
123 | u32 maxops; | ||
124 | u32 maxreqs; | ||
125 | u32 nr_rdma_attrs; | ||
126 | u32 rdma_attrs; | ||
127 | }; | ||
128 | |||
125 | struct nfsd4_session { | 129 | struct nfsd4_session { |
126 | struct kref se_ref; | 130 | struct kref se_ref; |
127 | struct list_head se_hash; /* hash by sessionid */ | 131 | struct list_head se_hash; /* hash by sessionid */ |
@@ -129,11 +133,8 @@ struct nfsd4_session { | |||
129 | u32 se_flags; | 133 | u32 se_flags; |
130 | struct nfs4_client *se_client; /* for expire_client */ | 134 | struct nfs4_client *se_client; /* for expire_client */ |
131 | struct nfs4_sessionid se_sessionid; | 135 | struct nfs4_sessionid se_sessionid; |
132 | u32 se_fmaxreq_sz; | 136 | struct nfsd4_channel_attrs se_fchannel; |
133 | u32 se_fmaxresp_sz; | 137 | struct nfsd4_channel_attrs se_bchannel; |
134 | u32 se_fmaxresp_cached; | ||
135 | u32 se_fmaxops; | ||
136 | u32 se_fnumslots; | ||
137 | struct nfsd4_slot se_slots[]; /* forward channel slots */ | 138 | struct nfsd4_slot se_slots[]; /* forward channel slots */ |
138 | }; | 139 | }; |
139 | 140 | ||
@@ -185,7 +186,7 @@ struct nfs4_client { | |||
185 | struct svc_cred cl_cred; /* setclientid principal */ | 186 | struct svc_cred cl_cred; /* setclientid principal */ |
186 | clientid_t cl_clientid; /* generated by server */ | 187 | clientid_t cl_clientid; /* generated by server */ |
187 | nfs4_verifier cl_confirm; /* generated by server */ | 188 | nfs4_verifier cl_confirm; /* generated by server */ |
188 | struct nfs4_callback cl_callback; /* callback info */ | 189 | struct nfs4_cb_conn cl_cb_conn; /* callback info */ |
189 | atomic_t cl_count; /* ref count */ | 190 | atomic_t cl_count; /* ref count */ |
190 | u32 cl_firststate; /* recovery dir creation */ | 191 | u32 cl_firststate; /* recovery dir creation */ |
191 | 192 | ||
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h index f80d6013fdc3..2bacf7535069 100644 --- a/include/linux/nfsd/xdr4.h +++ b/include/linux/nfsd/xdr4.h | |||
@@ -64,10 +64,13 @@ static inline bool nfsd4_has_session(struct nfsd4_compound_state *cs) | |||
64 | 64 | ||
65 | struct nfsd4_change_info { | 65 | struct nfsd4_change_info { |
66 | u32 atomic; | 66 | u32 atomic; |
67 | bool change_supported; | ||
67 | u32 before_ctime_sec; | 68 | u32 before_ctime_sec; |
68 | u32 before_ctime_nsec; | 69 | u32 before_ctime_nsec; |
70 | u64 before_change; | ||
69 | u32 after_ctime_sec; | 71 | u32 after_ctime_sec; |
70 | u32 after_ctime_nsec; | 72 | u32 after_ctime_nsec; |
73 | u64 after_change; | ||
71 | }; | 74 | }; |
72 | 75 | ||
73 | struct nfsd4_access { | 76 | struct nfsd4_access { |
@@ -363,17 +366,6 @@ struct nfsd4_exchange_id { | |||
363 | int spa_how; | 366 | int spa_how; |
364 | }; | 367 | }; |
365 | 368 | ||
366 | struct nfsd4_channel_attrs { | ||
367 | u32 headerpadsz; | ||
368 | u32 maxreq_sz; | ||
369 | u32 maxresp_sz; | ||
370 | u32 maxresp_cached; | ||
371 | u32 maxops; | ||
372 | u32 maxreqs; | ||
373 | u32 nr_rdma_attrs; | ||
374 | u32 rdma_attrs; | ||
375 | }; | ||
376 | |||
377 | struct nfsd4_create_session { | 369 | struct nfsd4_create_session { |
378 | clientid_t clientid; | 370 | clientid_t clientid; |
379 | struct nfs4_sessionid sessionid; | 371 | struct nfs4_sessionid sessionid; |
@@ -503,10 +495,16 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp) | |||
503 | { | 495 | { |
504 | BUG_ON(!fhp->fh_pre_saved || !fhp->fh_post_saved); | 496 | BUG_ON(!fhp->fh_pre_saved || !fhp->fh_post_saved); |
505 | cinfo->atomic = 1; | 497 | cinfo->atomic = 1; |
506 | cinfo->before_ctime_sec = fhp->fh_pre_ctime.tv_sec; | 498 | cinfo->change_supported = IS_I_VERSION(fhp->fh_dentry->d_inode); |
507 | cinfo->before_ctime_nsec = fhp->fh_pre_ctime.tv_nsec; | 499 | if (cinfo->change_supported) { |
508 | cinfo->after_ctime_sec = fhp->fh_post_attr.ctime.tv_sec; | 500 | cinfo->before_change = fhp->fh_pre_change; |
509 | cinfo->after_ctime_nsec = fhp->fh_post_attr.ctime.tv_nsec; | 501 | cinfo->after_change = fhp->fh_post_change; |
502 | } else { | ||
503 | cinfo->before_ctime_sec = fhp->fh_pre_ctime.tv_sec; | ||
504 | cinfo->before_ctime_nsec = fhp->fh_pre_ctime.tv_nsec; | ||
505 | cinfo->after_ctime_sec = fhp->fh_post_attr.ctime.tv_sec; | ||
506 | cinfo->after_ctime_nsec = fhp->fh_post_attr.ctime.tv_nsec; | ||
507 | } | ||
510 | } | 508 | } |
511 | 509 | ||
512 | int nfs4svc_encode_voidres(struct svc_rqst *, __be32 *, void *); | 510 | int nfs4svc_encode_voidres(struct svc_rqst *, __be32 *, void *); |
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h index 092e82e0048c..93a7c08f869d 100644 --- a/include/linux/pci-acpi.h +++ b/include/linux/pci-acpi.h | |||
@@ -15,7 +15,7 @@ static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev) | |||
15 | { | 15 | { |
16 | struct pci_bus *pbus = pdev->bus; | 16 | struct pci_bus *pbus = pdev->bus; |
17 | /* Find a PCI root bus */ | 17 | /* Find a PCI root bus */ |
18 | while (pbus->parent) | 18 | while (!pci_is_root_bus(pbus)) |
19 | pbus = pbus->parent; | 19 | pbus = pbus->parent; |
20 | return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus), | 20 | return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus), |
21 | pbus->number); | 21 | pbus->number); |
@@ -23,7 +23,7 @@ static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev) | |||
23 | 23 | ||
24 | static inline acpi_handle acpi_pci_get_bridge_handle(struct pci_bus *pbus) | 24 | static inline acpi_handle acpi_pci_get_bridge_handle(struct pci_bus *pbus) |
25 | { | 25 | { |
26 | if (pbus->parent) | 26 | if (!pci_is_root_bus(pbus)) |
27 | return DEVICE_ACPI_HANDLE(&(pbus->self->dev)); | 27 | return DEVICE_ACPI_HANDLE(&(pbus->self->dev)); |
28 | return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus), | 28 | return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus), |
29 | pbus->number); | 29 | pbus->number); |
diff --git a/include/linux/pci.h b/include/linux/pci.h index 8e366bb0705f..d304ddf412d0 100644 --- a/include/linux/pci.h +++ b/include/linux/pci.h | |||
@@ -196,6 +196,7 @@ struct pci_cap_saved_state { | |||
196 | struct pcie_link_state; | 196 | struct pcie_link_state; |
197 | struct pci_vpd; | 197 | struct pci_vpd; |
198 | struct pci_sriov; | 198 | struct pci_sriov; |
199 | struct pci_ats; | ||
199 | 200 | ||
200 | /* | 201 | /* |
201 | * The pci_dev structure is used to describe PCI devices. | 202 | * The pci_dev structure is used to describe PCI devices. |
@@ -293,6 +294,7 @@ struct pci_dev { | |||
293 | struct pci_sriov *sriov; /* SR-IOV capability related */ | 294 | struct pci_sriov *sriov; /* SR-IOV capability related */ |
294 | struct pci_dev *physfn; /* the PF this VF is associated with */ | 295 | struct pci_dev *physfn; /* the PF this VF is associated with */ |
295 | }; | 296 | }; |
297 | struct pci_ats *ats; /* Address Translation Service */ | ||
296 | #endif | 298 | #endif |
297 | }; | 299 | }; |
298 | 300 | ||
@@ -607,8 +609,6 @@ extern void pci_sort_breadthfirst(void); | |||
607 | struct pci_dev __deprecated *pci_find_device(unsigned int vendor, | 609 | struct pci_dev __deprecated *pci_find_device(unsigned int vendor, |
608 | unsigned int device, | 610 | unsigned int device, |
609 | struct pci_dev *from); | 611 | struct pci_dev *from); |
610 | struct pci_dev __deprecated *pci_find_slot(unsigned int bus, | ||
611 | unsigned int devfn); | ||
612 | #endif /* CONFIG_PCI_LEGACY */ | 612 | #endif /* CONFIG_PCI_LEGACY */ |
613 | 613 | ||
614 | enum pci_lost_interrupt_reason { | 614 | enum pci_lost_interrupt_reason { |
@@ -647,6 +647,7 @@ int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn, | |||
647 | int where, u16 val); | 647 | int where, u16 val); |
648 | int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn, | 648 | int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn, |
649 | int where, u32 val); | 649 | int where, u32 val); |
650 | struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops); | ||
650 | 651 | ||
651 | static inline int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val) | 652 | static inline int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val) |
652 | { | 653 | { |
@@ -711,8 +712,8 @@ int pcix_get_mmrbc(struct pci_dev *dev); | |||
711 | int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc); | 712 | int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc); |
712 | int pcie_get_readrq(struct pci_dev *dev); | 713 | int pcie_get_readrq(struct pci_dev *dev); |
713 | int pcie_set_readrq(struct pci_dev *dev, int rq); | 714 | int pcie_set_readrq(struct pci_dev *dev, int rq); |
715 | int __pci_reset_function(struct pci_dev *dev); | ||
714 | int pci_reset_function(struct pci_dev *dev); | 716 | int pci_reset_function(struct pci_dev *dev); |
715 | int pci_execute_reset_function(struct pci_dev *dev); | ||
716 | void pci_update_resource(struct pci_dev *dev, int resno); | 717 | void pci_update_resource(struct pci_dev *dev, int resno); |
717 | int __must_check pci_assign_resource(struct pci_dev *dev, int i); | 718 | int __must_check pci_assign_resource(struct pci_dev *dev, int i); |
718 | int pci_select_bars(struct pci_dev *dev, unsigned long flags); | 719 | int pci_select_bars(struct pci_dev *dev, unsigned long flags); |
@@ -732,7 +733,7 @@ int pci_set_power_state(struct pci_dev *dev, pci_power_t state); | |||
732 | pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state); | 733 | pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state); |
733 | bool pci_pme_capable(struct pci_dev *dev, pci_power_t state); | 734 | bool pci_pme_capable(struct pci_dev *dev, pci_power_t state); |
734 | void pci_pme_active(struct pci_dev *dev, bool enable); | 735 | void pci_pme_active(struct pci_dev *dev, bool enable); |
735 | int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable); | 736 | int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable); |
736 | int pci_wake_from_d3(struct pci_dev *dev, bool enable); | 737 | int pci_wake_from_d3(struct pci_dev *dev, bool enable); |
737 | pci_power_t pci_target_state(struct pci_dev *dev); | 738 | pci_power_t pci_target_state(struct pci_dev *dev); |
738 | int pci_prepare_to_sleep(struct pci_dev *dev); | 739 | int pci_prepare_to_sleep(struct pci_dev *dev); |
@@ -798,7 +799,7 @@ const struct pci_device_id *pci_match_id(const struct pci_device_id *ids, | |||
798 | int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, | 799 | int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, |
799 | int pass); | 800 | int pass); |
800 | 801 | ||
801 | void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *), | 802 | void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *), |
802 | void *userdata); | 803 | void *userdata); |
803 | int pci_cfg_space_size_ext(struct pci_dev *dev); | 804 | int pci_cfg_space_size_ext(struct pci_dev *dev); |
804 | int pci_cfg_space_size(struct pci_dev *dev); | 805 | int pci_cfg_space_size(struct pci_dev *dev); |
@@ -888,6 +889,17 @@ static inline int pcie_aspm_enabled(void) | |||
888 | extern int pcie_aspm_enabled(void); | 889 | extern int pcie_aspm_enabled(void); |
889 | #endif | 890 | #endif |
890 | 891 | ||
892 | #ifndef CONFIG_PCIE_ECRC | ||
893 | static inline void pcie_set_ecrc_checking(struct pci_dev *dev) | ||
894 | { | ||
895 | return; | ||
896 | } | ||
897 | static inline void pcie_ecrc_get_policy(char *str) {}; | ||
898 | #else | ||
899 | extern void pcie_set_ecrc_checking(struct pci_dev *dev); | ||
900 | extern void pcie_ecrc_get_policy(char *str); | ||
901 | #endif | ||
902 | |||
891 | #define pci_enable_msi(pdev) pci_enable_msi_block(pdev, 1) | 903 | #define pci_enable_msi(pdev) pci_enable_msi_block(pdev, 1) |
892 | 904 | ||
893 | #ifdef CONFIG_HT_IRQ | 905 | #ifdef CONFIG_HT_IRQ |
@@ -944,12 +956,6 @@ static inline struct pci_dev *pci_find_device(unsigned int vendor, | |||
944 | return NULL; | 956 | return NULL; |
945 | } | 957 | } |
946 | 958 | ||
947 | static inline struct pci_dev *pci_find_slot(unsigned int bus, | ||
948 | unsigned int devfn) | ||
949 | { | ||
950 | return NULL; | ||
951 | } | ||
952 | |||
953 | static inline struct pci_dev *pci_get_device(unsigned int vendor, | 959 | static inline struct pci_dev *pci_get_device(unsigned int vendor, |
954 | unsigned int device, | 960 | unsigned int device, |
955 | struct pci_dev *from) | 961 | struct pci_dev *from) |
@@ -1105,6 +1111,10 @@ static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus, | |||
1105 | 1111 | ||
1106 | #include <asm/pci.h> | 1112 | #include <asm/pci.h> |
1107 | 1113 | ||
1114 | #ifndef PCIBIOS_MAX_MEM_32 | ||
1115 | #define PCIBIOS_MAX_MEM_32 (-1) | ||
1116 | #endif | ||
1117 | |||
1108 | /* these helpers provide future and backwards compatibility | 1118 | /* these helpers provide future and backwards compatibility |
1109 | * for accessing popular PCI BAR info */ | 1119 | * for accessing popular PCI BAR info */ |
1110 | #define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start) | 1120 | #define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start) |
@@ -1261,5 +1271,10 @@ static inline irqreturn_t pci_sriov_migration(struct pci_dev *dev) | |||
1261 | } | 1271 | } |
1262 | #endif | 1272 | #endif |
1263 | 1273 | ||
1274 | #if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE) | ||
1275 | extern void pci_hp_create_module_link(struct pci_slot *pci_slot); | ||
1276 | extern void pci_hp_remove_module_link(struct pci_slot *pci_slot); | ||
1277 | #endif | ||
1278 | |||
1264 | #endif /* __KERNEL__ */ | 1279 | #endif /* __KERNEL__ */ |
1265 | #endif /* LINUX_PCI_H */ | 1280 | #endif /* LINUX_PCI_H */ |
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h index 20998746518e..4391741b99dc 100644 --- a/include/linux/pci_hotplug.h +++ b/include/linux/pci_hotplug.h | |||
@@ -66,17 +66,10 @@ enum pcie_link_speed { | |||
66 | PCIE_LNK_SPEED_UNKNOWN = 0xFF, | 66 | PCIE_LNK_SPEED_UNKNOWN = 0xFF, |
67 | }; | 67 | }; |
68 | 68 | ||
69 | struct hotplug_slot; | ||
70 | struct hotplug_slot_attribute { | ||
71 | struct attribute attr; | ||
72 | ssize_t (*show)(struct hotplug_slot *, char *); | ||
73 | ssize_t (*store)(struct hotplug_slot *, const char *, size_t); | ||
74 | }; | ||
75 | #define to_hotplug_attr(n) container_of(n, struct hotplug_slot_attribute, attr); | ||
76 | |||
77 | /** | 69 | /** |
78 | * struct hotplug_slot_ops -the callbacks that the hotplug pci core can use | 70 | * struct hotplug_slot_ops -the callbacks that the hotplug pci core can use |
79 | * @owner: The module owner of this structure | 71 | * @owner: The module owner of this structure |
72 | * @mod_name: The module name (KBUILD_MODNAME) of this structure | ||
80 | * @enable_slot: Called when the user wants to enable a specific pci slot | 73 | * @enable_slot: Called when the user wants to enable a specific pci slot |
81 | * @disable_slot: Called when the user wants to disable a specific pci slot | 74 | * @disable_slot: Called when the user wants to disable a specific pci slot |
82 | * @set_attention_status: Called to set the specific slot's attention LED to | 75 | * @set_attention_status: Called to set the specific slot's attention LED to |
@@ -109,6 +102,7 @@ struct hotplug_slot_attribute { | |||
109 | */ | 102 | */ |
110 | struct hotplug_slot_ops { | 103 | struct hotplug_slot_ops { |
111 | struct module *owner; | 104 | struct module *owner; |
105 | const char *mod_name; | ||
112 | int (*enable_slot) (struct hotplug_slot *slot); | 106 | int (*enable_slot) (struct hotplug_slot *slot); |
113 | int (*disable_slot) (struct hotplug_slot *slot); | 107 | int (*disable_slot) (struct hotplug_slot *slot); |
114 | int (*set_attention_status) (struct hotplug_slot *slot, u8 value); | 108 | int (*set_attention_status) (struct hotplug_slot *slot, u8 value); |
@@ -167,12 +161,21 @@ static inline const char *hotplug_slot_name(const struct hotplug_slot *slot) | |||
167 | return pci_slot_name(slot->pci_slot); | 161 | return pci_slot_name(slot->pci_slot); |
168 | } | 162 | } |
169 | 163 | ||
170 | extern int pci_hp_register(struct hotplug_slot *, struct pci_bus *, int nr, | 164 | extern int __pci_hp_register(struct hotplug_slot *slot, struct pci_bus *pbus, |
171 | const char *name); | 165 | int nr, const char *name, |
166 | struct module *owner, const char *mod_name); | ||
172 | extern int pci_hp_deregister(struct hotplug_slot *slot); | 167 | extern int pci_hp_deregister(struct hotplug_slot *slot); |
173 | extern int __must_check pci_hp_change_slot_info (struct hotplug_slot *slot, | 168 | extern int __must_check pci_hp_change_slot_info (struct hotplug_slot *slot, |
174 | struct hotplug_slot_info *info); | 169 | struct hotplug_slot_info *info); |
175 | 170 | ||
171 | static inline int pci_hp_register(struct hotplug_slot *slot, | ||
172 | struct pci_bus *pbus, | ||
173 | int devnr, const char *name) | ||
174 | { | ||
175 | return __pci_hp_register(slot, pbus, devnr, name, | ||
176 | THIS_MODULE, KBUILD_MODNAME); | ||
177 | } | ||
178 | |||
176 | /* PCI Setting Record (Type 0) */ | 179 | /* PCI Setting Record (Type 0) */ |
177 | struct hpp_type0 { | 180 | struct hpp_type0 { |
178 | u32 revision; | 181 | u32 revision; |
@@ -226,7 +229,6 @@ struct hotplug_params { | |||
226 | extern acpi_status acpi_get_hp_params_from_firmware(struct pci_bus *bus, | 229 | extern acpi_status acpi_get_hp_params_from_firmware(struct pci_bus *bus, |
227 | struct hotplug_params *hpp); | 230 | struct hotplug_params *hpp); |
228 | int acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev, u32 flags); | 231 | int acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev, u32 flags); |
229 | int acpi_root_bridge(acpi_handle handle); | ||
230 | int acpi_pci_check_ejectable(struct pci_bus *pbus, acpi_handle handle); | 232 | int acpi_pci_check_ejectable(struct pci_bus *pbus, acpi_handle handle); |
231 | int acpi_pci_detect_ejectable(struct pci_bus *pbus); | 233 | int acpi_pci_detect_ejectable(struct pci_bus *pbus); |
232 | #endif | 234 | #endif |
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h index 616bf8b3c8b5..fcaee42c7ac2 100644 --- a/include/linux/pci_regs.h +++ b/include/linux/pci_regs.h | |||
@@ -295,8 +295,9 @@ | |||
295 | #define PCI_MSI_ADDRESS_LO 4 /* Lower 32 bits */ | 295 | #define PCI_MSI_ADDRESS_LO 4 /* Lower 32 bits */ |
296 | #define PCI_MSI_ADDRESS_HI 8 /* Upper 32 bits (if PCI_MSI_FLAGS_64BIT set) */ | 296 | #define PCI_MSI_ADDRESS_HI 8 /* Upper 32 bits (if PCI_MSI_FLAGS_64BIT set) */ |
297 | #define PCI_MSI_DATA_32 8 /* 16 bits of data for 32-bit devices */ | 297 | #define PCI_MSI_DATA_32 8 /* 16 bits of data for 32-bit devices */ |
298 | #define PCI_MSI_MASK_32 12 /* Mask bits register for 32-bit devices */ | ||
298 | #define PCI_MSI_DATA_64 12 /* 16 bits of data for 64-bit devices */ | 299 | #define PCI_MSI_DATA_64 12 /* 16 bits of data for 64-bit devices */ |
299 | #define PCI_MSI_MASK_BIT 16 /* Mask bits register */ | 300 | #define PCI_MSI_MASK_64 16 /* Mask bits register for 64-bit devices */ |
300 | 301 | ||
301 | /* MSI-X registers (these are at offset PCI_MSIX_FLAGS) */ | 302 | /* MSI-X registers (these are at offset PCI_MSIX_FLAGS) */ |
302 | #define PCI_MSIX_FLAGS 2 | 303 | #define PCI_MSIX_FLAGS 2 |
@@ -304,7 +305,6 @@ | |||
304 | #define PCI_MSIX_FLAGS_ENABLE (1 << 15) | 305 | #define PCI_MSIX_FLAGS_ENABLE (1 << 15) |
305 | #define PCI_MSIX_FLAGS_MASKALL (1 << 14) | 306 | #define PCI_MSIX_FLAGS_MASKALL (1 << 14) |
306 | #define PCI_MSIX_FLAGS_BIRMASK (7 << 0) | 307 | #define PCI_MSIX_FLAGS_BIRMASK (7 << 0) |
307 | #define PCI_MSIX_FLAGS_BITMASK (1 << 0) | ||
308 | 308 | ||
309 | /* CompactPCI Hotswap Register */ | 309 | /* CompactPCI Hotswap Register */ |
310 | 310 | ||
@@ -502,6 +502,7 @@ | |||
502 | #define PCI_EXT_CAP_ID_DSN 3 | 502 | #define PCI_EXT_CAP_ID_DSN 3 |
503 | #define PCI_EXT_CAP_ID_PWR 4 | 503 | #define PCI_EXT_CAP_ID_PWR 4 |
504 | #define PCI_EXT_CAP_ID_ARI 14 | 504 | #define PCI_EXT_CAP_ID_ARI 14 |
505 | #define PCI_EXT_CAP_ID_ATS 15 | ||
505 | #define PCI_EXT_CAP_ID_SRIOV 16 | 506 | #define PCI_EXT_CAP_ID_SRIOV 16 |
506 | 507 | ||
507 | /* Advanced Error Reporting */ | 508 | /* Advanced Error Reporting */ |
@@ -620,6 +621,15 @@ | |||
620 | #define PCI_ARI_CTRL_ACS 0x0002 /* ACS Function Groups Enable */ | 621 | #define PCI_ARI_CTRL_ACS 0x0002 /* ACS Function Groups Enable */ |
621 | #define PCI_ARI_CTRL_FG(x) (((x) >> 4) & 7) /* Function Group */ | 622 | #define PCI_ARI_CTRL_FG(x) (((x) >> 4) & 7) /* Function Group */ |
622 | 623 | ||
624 | /* Address Translation Service */ | ||
625 | #define PCI_ATS_CAP 0x04 /* ATS Capability Register */ | ||
626 | #define PCI_ATS_CAP_QDEP(x) ((x) & 0x1f) /* Invalidate Queue Depth */ | ||
627 | #define PCI_ATS_MAX_QDEP 32 /* Max Invalidate Queue Depth */ | ||
628 | #define PCI_ATS_CTRL 0x06 /* ATS Control Register */ | ||
629 | #define PCI_ATS_CTRL_ENABLE 0x8000 /* ATS Enable */ | ||
630 | #define PCI_ATS_CTRL_STU(x) ((x) & 0x1f) /* Smallest Translation Unit */ | ||
631 | #define PCI_ATS_MIN_STU 12 /* shift of minimum STU block */ | ||
632 | |||
623 | /* Single Root I/O Virtualization */ | 633 | /* Single Root I/O Virtualization */ |
624 | #define PCI_SRIOV_CAP 0x04 /* SR-IOV Capabilities */ | 634 | #define PCI_SRIOV_CAP 0x04 /* SR-IOV Capabilities */ |
625 | #define PCI_SRIOV_CAP_VFM 0x01 /* VF Migration Capable */ | 635 | #define PCI_SRIOV_CAP_VFM 0x01 /* VF Migration Capable */ |
diff --git a/include/linux/perf_counter.h b/include/linux/perf_counter.h index 1b3118a1023a..89698d8aba5c 100644 --- a/include/linux/perf_counter.h +++ b/include/linux/perf_counter.h | |||
@@ -236,10 +236,16 @@ struct perf_counter_mmap_page { | |||
236 | /* | 236 | /* |
237 | * Control data for the mmap() data buffer. | 237 | * Control data for the mmap() data buffer. |
238 | * | 238 | * |
239 | * User-space reading this value should issue an rmb(), on SMP capable | 239 | * User-space reading the @data_head value should issue an rmb(), on |
240 | * platforms, after reading this value -- see perf_counter_wakeup(). | 240 | * SMP capable platforms, after reading this value -- see |
241 | * perf_counter_wakeup(). | ||
242 | * | ||
243 | * When the mapping is PROT_WRITE the @data_tail value should be | ||
244 | * written by userspace to reflect the last read data. In this case | ||
245 | * the kernel will not over-write unread data. | ||
241 | */ | 246 | */ |
242 | __u64 data_head; /* head in the data section */ | 247 | __u64 data_head; /* head in the data section */ |
248 | __u64 data_tail; /* user-space written tail */ | ||
243 | }; | 249 | }; |
244 | 250 | ||
245 | #define PERF_EVENT_MISC_CPUMODE_MASK (3 << 0) | 251 | #define PERF_EVENT_MISC_CPUMODE_MASK (3 << 0) |
@@ -275,6 +281,15 @@ enum perf_event_type { | |||
275 | 281 | ||
276 | /* | 282 | /* |
277 | * struct { | 283 | * struct { |
284 | * struct perf_event_header header; | ||
285 | * u64 id; | ||
286 | * u64 lost; | ||
287 | * }; | ||
288 | */ | ||
289 | PERF_EVENT_LOST = 2, | ||
290 | |||
291 | /* | ||
292 | * struct { | ||
278 | * struct perf_event_header header; | 293 | * struct perf_event_header header; |
279 | * | 294 | * |
280 | * u32 pid, tid; | 295 | * u32 pid, tid; |
@@ -313,30 +328,39 @@ enum perf_event_type { | |||
313 | 328 | ||
314 | /* | 329 | /* |
315 | * When header.misc & PERF_EVENT_MISC_OVERFLOW the event_type field | 330 | * When header.misc & PERF_EVENT_MISC_OVERFLOW the event_type field |
316 | * will be PERF_RECORD_* | 331 | * will be PERF_SAMPLE_* |
317 | * | 332 | * |
318 | * struct { | 333 | * struct { |
319 | * struct perf_event_header header; | 334 | * struct perf_event_header header; |
320 | * | 335 | * |
321 | * { u64 ip; } && PERF_RECORD_IP | 336 | * { u64 ip; } && PERF_SAMPLE_IP |
322 | * { u32 pid, tid; } && PERF_RECORD_TID | 337 | * { u32 pid, tid; } && PERF_SAMPLE_TID |
323 | * { u64 time; } && PERF_RECORD_TIME | 338 | * { u64 time; } && PERF_SAMPLE_TIME |
324 | * { u64 addr; } && PERF_RECORD_ADDR | 339 | * { u64 addr; } && PERF_SAMPLE_ADDR |
325 | * { u64 config; } && PERF_RECORD_CONFIG | 340 | * { u64 config; } && PERF_SAMPLE_CONFIG |
326 | * { u32 cpu, res; } && PERF_RECORD_CPU | 341 | * { u32 cpu, res; } && PERF_SAMPLE_CPU |
327 | * | 342 | * |
328 | * { u64 nr; | 343 | * { u64 nr; |
329 | * { u64 id, val; } cnt[nr]; } && PERF_RECORD_GROUP | 344 | * { u64 id, val; } cnt[nr]; } && PERF_SAMPLE_GROUP |
330 | * | 345 | * |
331 | * { u16 nr, | 346 | * { u64 nr, |
332 | * hv, | 347 | * u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN |
333 | * kernel, | ||
334 | * user; | ||
335 | * u64 ips[nr]; } && PERF_RECORD_CALLCHAIN | ||
336 | * }; | 348 | * }; |
337 | */ | 349 | */ |
338 | }; | 350 | }; |
339 | 351 | ||
352 | enum perf_callchain_context { | ||
353 | PERF_CONTEXT_HV = (__u64)-32, | ||
354 | PERF_CONTEXT_KERNEL = (__u64)-128, | ||
355 | PERF_CONTEXT_USER = (__u64)-512, | ||
356 | |||
357 | PERF_CONTEXT_GUEST = (__u64)-2048, | ||
358 | PERF_CONTEXT_GUEST_KERNEL = (__u64)-2176, | ||
359 | PERF_CONTEXT_GUEST_USER = (__u64)-2560, | ||
360 | |||
361 | PERF_CONTEXT_MAX = (__u64)-4095, | ||
362 | }; | ||
363 | |||
340 | #ifdef __KERNEL__ | 364 | #ifdef __KERNEL__ |
341 | /* | 365 | /* |
342 | * Kernel-internal data types and definitions: | 366 | * Kernel-internal data types and definitions: |
@@ -356,6 +380,13 @@ enum perf_event_type { | |||
356 | #include <linux/pid_namespace.h> | 380 | #include <linux/pid_namespace.h> |
357 | #include <asm/atomic.h> | 381 | #include <asm/atomic.h> |
358 | 382 | ||
383 | #define PERF_MAX_STACK_DEPTH 255 | ||
384 | |||
385 | struct perf_callchain_entry { | ||
386 | __u64 nr; | ||
387 | __u64 ip[PERF_MAX_STACK_DEPTH]; | ||
388 | }; | ||
389 | |||
359 | struct task_struct; | 390 | struct task_struct; |
360 | 391 | ||
361 | /** | 392 | /** |
@@ -414,6 +445,7 @@ struct file; | |||
414 | struct perf_mmap_data { | 445 | struct perf_mmap_data { |
415 | struct rcu_head rcu_head; | 446 | struct rcu_head rcu_head; |
416 | int nr_pages; /* nr of data pages */ | 447 | int nr_pages; /* nr of data pages */ |
448 | int writable; /* are we writable */ | ||
417 | int nr_locked; /* nr pages mlocked */ | 449 | int nr_locked; /* nr pages mlocked */ |
418 | 450 | ||
419 | atomic_t poll; /* POLL_ for wakeups */ | 451 | atomic_t poll; /* POLL_ for wakeups */ |
@@ -423,8 +455,8 @@ struct perf_mmap_data { | |||
423 | atomic_long_t done_head; /* completed head */ | 455 | atomic_long_t done_head; /* completed head */ |
424 | 456 | ||
425 | atomic_t lock; /* concurrent writes */ | 457 | atomic_t lock; /* concurrent writes */ |
426 | |||
427 | atomic_t wakeup; /* needs a wakeup */ | 458 | atomic_t wakeup; /* needs a wakeup */ |
459 | atomic_t lost; /* nr records lost */ | ||
428 | 460 | ||
429 | struct perf_counter_mmap_page *user_page; | 461 | struct perf_counter_mmap_page *user_page; |
430 | void *data_pages[0]; | 462 | void *data_pages[0]; |
@@ -604,6 +636,7 @@ extern void perf_counter_task_tick(struct task_struct *task, int cpu); | |||
604 | extern int perf_counter_init_task(struct task_struct *child); | 636 | extern int perf_counter_init_task(struct task_struct *child); |
605 | extern void perf_counter_exit_task(struct task_struct *child); | 637 | extern void perf_counter_exit_task(struct task_struct *child); |
606 | extern void perf_counter_free_task(struct task_struct *task); | 638 | extern void perf_counter_free_task(struct task_struct *task); |
639 | extern void set_perf_counter_pending(void); | ||
607 | extern void perf_counter_do_pending(void); | 640 | extern void perf_counter_do_pending(void); |
608 | extern void perf_counter_print_debug(void); | 641 | extern void perf_counter_print_debug(void); |
609 | extern void __perf_disable(void); | 642 | extern void __perf_disable(void); |
@@ -649,18 +682,6 @@ static inline void perf_counter_mmap(struct vm_area_struct *vma) | |||
649 | extern void perf_counter_comm(struct task_struct *tsk); | 682 | extern void perf_counter_comm(struct task_struct *tsk); |
650 | extern void perf_counter_fork(struct task_struct *tsk); | 683 | extern void perf_counter_fork(struct task_struct *tsk); |
651 | 684 | ||
652 | extern void perf_counter_task_migration(struct task_struct *task, int cpu); | ||
653 | |||
654 | #define MAX_STACK_DEPTH 255 | ||
655 | |||
656 | struct perf_callchain_entry { | ||
657 | u16 nr; | ||
658 | u16 hv; | ||
659 | u16 kernel; | ||
660 | u16 user; | ||
661 | u64 ip[MAX_STACK_DEPTH]; | ||
662 | }; | ||
663 | |||
664 | extern struct perf_callchain_entry *perf_callchain(struct pt_regs *regs); | 685 | extern struct perf_callchain_entry *perf_callchain(struct pt_regs *regs); |
665 | 686 | ||
666 | extern int sysctl_perf_counter_paranoid; | 687 | extern int sysctl_perf_counter_paranoid; |
@@ -701,8 +722,6 @@ static inline void perf_counter_mmap(struct vm_area_struct *vma) { } | |||
701 | static inline void perf_counter_comm(struct task_struct *tsk) { } | 722 | static inline void perf_counter_comm(struct task_struct *tsk) { } |
702 | static inline void perf_counter_fork(struct task_struct *tsk) { } | 723 | static inline void perf_counter_fork(struct task_struct *tsk) { } |
703 | static inline void perf_counter_init(void) { } | 724 | static inline void perf_counter_init(void) { } |
704 | static inline void perf_counter_task_migration(struct task_struct *task, | ||
705 | int cpu) { } | ||
706 | #endif | 725 | #endif |
707 | 726 | ||
708 | #endif /* __KERNEL__ */ | 727 | #endif /* __KERNEL__ */ |
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h index 4bc241290c24..065a3652a3ea 100644 --- a/include/linux/posix_acl.h +++ b/include/linux/posix_acl.h | |||
@@ -83,4 +83,78 @@ extern int posix_acl_chmod_masq(struct posix_acl *, mode_t); | |||
83 | extern struct posix_acl *get_posix_acl(struct inode *, int); | 83 | extern struct posix_acl *get_posix_acl(struct inode *, int); |
84 | extern int set_posix_acl(struct inode *, int, struct posix_acl *); | 84 | extern int set_posix_acl(struct inode *, int, struct posix_acl *); |
85 | 85 | ||
86 | #ifdef CONFIG_FS_POSIX_ACL | ||
87 | static inline struct posix_acl *get_cached_acl(struct inode *inode, int type) | ||
88 | { | ||
89 | struct posix_acl **p, *acl; | ||
90 | switch (type) { | ||
91 | case ACL_TYPE_ACCESS: | ||
92 | p = &inode->i_acl; | ||
93 | break; | ||
94 | case ACL_TYPE_DEFAULT: | ||
95 | p = &inode->i_default_acl; | ||
96 | break; | ||
97 | default: | ||
98 | return ERR_PTR(-EINVAL); | ||
99 | } | ||
100 | acl = ACCESS_ONCE(*p); | ||
101 | if (acl) { | ||
102 | spin_lock(&inode->i_lock); | ||
103 | acl = *p; | ||
104 | if (acl != ACL_NOT_CACHED) | ||
105 | acl = posix_acl_dup(acl); | ||
106 | spin_unlock(&inode->i_lock); | ||
107 | } | ||
108 | return acl; | ||
109 | } | ||
110 | |||
111 | static inline void set_cached_acl(struct inode *inode, | ||
112 | int type, | ||
113 | struct posix_acl *acl) | ||
114 | { | ||
115 | struct posix_acl *old = NULL; | ||
116 | spin_lock(&inode->i_lock); | ||
117 | switch (type) { | ||
118 | case ACL_TYPE_ACCESS: | ||
119 | old = inode->i_acl; | ||
120 | inode->i_acl = posix_acl_dup(acl); | ||
121 | break; | ||
122 | case ACL_TYPE_DEFAULT: | ||
123 | old = inode->i_default_acl; | ||
124 | inode->i_default_acl = posix_acl_dup(acl); | ||
125 | break; | ||
126 | } | ||
127 | spin_unlock(&inode->i_lock); | ||
128 | if (old != ACL_NOT_CACHED) | ||
129 | posix_acl_release(old); | ||
130 | } | ||
131 | |||
132 | static inline void forget_cached_acl(struct inode *inode, int type) | ||
133 | { | ||
134 | struct posix_acl *old = NULL; | ||
135 | spin_lock(&inode->i_lock); | ||
136 | switch (type) { | ||
137 | case ACL_TYPE_ACCESS: | ||
138 | old = inode->i_acl; | ||
139 | inode->i_acl = ACL_NOT_CACHED; | ||
140 | break; | ||
141 | case ACL_TYPE_DEFAULT: | ||
142 | old = inode->i_default_acl; | ||
143 | inode->i_default_acl = ACL_NOT_CACHED; | ||
144 | break; | ||
145 | } | ||
146 | spin_unlock(&inode->i_lock); | ||
147 | if (old != ACL_NOT_CACHED) | ||
148 | posix_acl_release(old); | ||
149 | } | ||
150 | #endif | ||
151 | |||
152 | static inline void cache_no_acl(struct inode *inode) | ||
153 | { | ||
154 | #ifdef CONFIG_FS_POSIX_ACL | ||
155 | inode->i_acl = NULL; | ||
156 | inode->i_default_acl = NULL; | ||
157 | #endif | ||
158 | } | ||
159 | |||
86 | #endif /* __LINUX_POSIX_ACL_H */ | 160 | #endif /* __LINUX_POSIX_ACL_H */ |
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h index 8cc65757e47a..b4448853900e 100644 --- a/include/linux/reiserfs_acl.h +++ b/include/linux/reiserfs_acl.h | |||
@@ -56,15 +56,6 @@ int reiserfs_cache_default_acl(struct inode *dir); | |||
56 | extern struct xattr_handler reiserfs_posix_acl_default_handler; | 56 | extern struct xattr_handler reiserfs_posix_acl_default_handler; |
57 | extern struct xattr_handler reiserfs_posix_acl_access_handler; | 57 | extern struct xattr_handler reiserfs_posix_acl_access_handler; |
58 | 58 | ||
59 | static inline void reiserfs_init_acl_access(struct inode *inode) | ||
60 | { | ||
61 | REISERFS_I(inode)->i_acl_access = NULL; | ||
62 | } | ||
63 | |||
64 | static inline void reiserfs_init_acl_default(struct inode *inode) | ||
65 | { | ||
66 | REISERFS_I(inode)->i_acl_default = NULL; | ||
67 | } | ||
68 | #else | 59 | #else |
69 | 60 | ||
70 | #define reiserfs_cache_default_acl(inode) 0 | 61 | #define reiserfs_cache_default_acl(inode) 0 |
@@ -86,12 +77,4 @@ reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th, | |||
86 | { | 77 | { |
87 | return 0; | 78 | return 0; |
88 | } | 79 | } |
89 | |||
90 | static inline void reiserfs_init_acl_access(struct inode *inode) | ||
91 | { | ||
92 | } | ||
93 | |||
94 | static inline void reiserfs_init_acl_default(struct inode *inode) | ||
95 | { | ||
96 | } | ||
97 | #endif | 80 | #endif |
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h index 76360b36ac33..89f4d3abbf5a 100644 --- a/include/linux/reiserfs_fs_i.h +++ b/include/linux/reiserfs_fs_i.h | |||
@@ -54,10 +54,6 @@ struct reiserfs_inode_info { | |||
54 | unsigned int i_trans_id; | 54 | unsigned int i_trans_id; |
55 | struct reiserfs_journal_list *i_jl; | 55 | struct reiserfs_journal_list *i_jl; |
56 | struct mutex i_mmap; | 56 | struct mutex i_mmap; |
57 | #ifdef CONFIG_REISERFS_FS_POSIX_ACL | ||
58 | struct posix_acl *i_acl_access; | ||
59 | struct posix_acl *i_acl_default; | ||
60 | #endif | ||
61 | #ifdef CONFIG_REISERFS_FS_XATTR | 57 | #ifdef CONFIG_REISERFS_FS_XATTR |
62 | struct rw_semaphore i_xattr_sem; | 58 | struct rw_semaphore i_xattr_sem; |
63 | #endif | 59 | #endif |
diff --git a/include/linux/rfkill.h b/include/linux/rfkill.h index 16e39c7a67fc..e73e2429a1b1 100644 --- a/include/linux/rfkill.h +++ b/include/linux/rfkill.h | |||
@@ -160,8 +160,9 @@ struct rfkill * __must_check rfkill_alloc(const char *name, | |||
160 | * the rfkill structure. Before calling this function the driver needs | 160 | * the rfkill structure. Before calling this function the driver needs |
161 | * to be ready to service method calls from rfkill. | 161 | * to be ready to service method calls from rfkill. |
162 | * | 162 | * |
163 | * If the software blocked state is not set before registration, | 163 | * If rfkill_init_sw_state() is not called before registration, |
164 | * set_block will be called to initialize it to a default value. | 164 | * set_block() will be called to initialize the software blocked state |
165 | * to a default value. | ||
165 | * | 166 | * |
166 | * If the hardware blocked state is not set before registration, | 167 | * If the hardware blocked state is not set before registration, |
167 | * it is assumed to be unblocked. | 168 | * it is assumed to be unblocked. |
@@ -234,9 +235,11 @@ bool __must_check rfkill_set_hw_state(struct rfkill *rfkill, bool blocked); | |||
234 | * rfkill drivers that get events when the soft-blocked state changes | 235 | * rfkill drivers that get events when the soft-blocked state changes |
235 | * (yes, some platforms directly act on input but allow changing again) | 236 | * (yes, some platforms directly act on input but allow changing again) |
236 | * use this function to notify the rfkill core (and through that also | 237 | * use this function to notify the rfkill core (and through that also |
237 | * userspace) of the current state. It is not necessary to notify on | 238 | * userspace) of the current state. |
238 | * resume; since hibernation can always change the soft-blocked state, | 239 | * |
239 | * the rfkill core will unconditionally restore the previous state. | 240 | * Drivers should also call this function after resume if the state has |
241 | * been changed by the user. This only makes sense for "persistent" | ||
242 | * devices (see rfkill_init_sw_state()). | ||
240 | * | 243 | * |
241 | * This function can be called in any context, even from within rfkill | 244 | * This function can be called in any context, even from within rfkill |
242 | * callbacks. | 245 | * callbacks. |
@@ -247,6 +250,22 @@ bool __must_check rfkill_set_hw_state(struct rfkill *rfkill, bool blocked); | |||
247 | bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked); | 250 | bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked); |
248 | 251 | ||
249 | /** | 252 | /** |
253 | * rfkill_init_sw_state - Initialize persistent software block state | ||
254 | * @rfkill: pointer to the rfkill class to modify. | ||
255 | * @state: the current software block state to set | ||
256 | * | ||
257 | * rfkill drivers that preserve their software block state over power off | ||
258 | * use this function to notify the rfkill core (and through that also | ||
259 | * userspace) of their initial state. It should only be used before | ||
260 | * registration. | ||
261 | * | ||
262 | * In addition, it marks the device as "persistent", an attribute which | ||
263 | * can be read by userspace. Persistent devices are expected to preserve | ||
264 | * their own state when suspended. | ||
265 | */ | ||
266 | void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked); | ||
267 | |||
268 | /** | ||
250 | * rfkill_set_states - Set the internal rfkill block states | 269 | * rfkill_set_states - Set the internal rfkill block states |
251 | * @rfkill: pointer to the rfkill class to modify. | 270 | * @rfkill: pointer to the rfkill class to modify. |
252 | * @sw: the current software block state to set | 271 | * @sw: the current software block state to set |
@@ -307,6 +326,10 @@ static inline bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked) | |||
307 | return blocked; | 326 | return blocked; |
308 | } | 327 | } |
309 | 328 | ||
329 | static inline void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked) | ||
330 | { | ||
331 | } | ||
332 | |||
310 | static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw) | 333 | static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw) |
311 | { | 334 | { |
312 | } | 335 | } |
diff --git a/include/linux/rmap.h b/include/linux/rmap.h index 216d024f830d..bf116d0dbf23 100644 --- a/include/linux/rmap.h +++ b/include/linux/rmap.h | |||
@@ -118,7 +118,14 @@ int try_to_munlock(struct page *); | |||
118 | #define anon_vma_prepare(vma) (0) | 118 | #define anon_vma_prepare(vma) (0) |
119 | #define anon_vma_link(vma) do {} while (0) | 119 | #define anon_vma_link(vma) do {} while (0) |
120 | 120 | ||
121 | #define page_referenced(page, locked, cnt, flags) TestClearPageReferenced(page) | 121 | static inline int page_referenced(struct page *page, int is_locked, |
122 | struct mem_cgroup *cnt, | ||
123 | unsigned long *vm_flags) | ||
124 | { | ||
125 | *vm_flags = 0; | ||
126 | return TestClearPageReferenced(page); | ||
127 | } | ||
128 | |||
122 | #define try_to_unmap(page, refs) SWAP_FAIL | 129 | #define try_to_unmap(page, refs) SWAP_FAIL |
123 | 130 | ||
124 | static inline int page_mkclean(struct page *page) | 131 | static inline int page_mkclean(struct page *page) |
diff --git a/include/linux/rotary_encoder.h b/include/linux/rotary_encoder.h index 12d63a30c347..215278b8df2a 100644 --- a/include/linux/rotary_encoder.h +++ b/include/linux/rotary_encoder.h | |||
@@ -8,6 +8,8 @@ struct rotary_encoder_platform_data { | |||
8 | unsigned int gpio_b; | 8 | unsigned int gpio_b; |
9 | unsigned int inverted_a; | 9 | unsigned int inverted_a; |
10 | unsigned int inverted_b; | 10 | unsigned int inverted_b; |
11 | bool relative_axis; | ||
12 | bool rollover; | ||
11 | }; | 13 | }; |
12 | 14 | ||
13 | #endif /* __ROTARY_ENCODER_H__ */ | 15 | #endif /* __ROTARY_ENCODER_H__ */ |
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 6fd80c4243f1..23d2fb051f97 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h | |||
@@ -171,6 +171,9 @@ | |||
171 | /* Timberdale UART */ | 171 | /* Timberdale UART */ |
172 | #define PORT_TIMBUART 87 | 172 | #define PORT_TIMBUART 87 |
173 | 173 | ||
174 | /* Qualcomm MSM SoCs */ | ||
175 | #define PORT_MSM 88 | ||
176 | |||
174 | #ifdef __KERNEL__ | 177 | #ifdef __KERNEL__ |
175 | 178 | ||
176 | #include <linux/compiler.h> | 179 | #include <linux/compiler.h> |
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h index 96c0d93fc2ca..850db2e80510 100644 --- a/include/linux/serial_reg.h +++ b/include/linux/serial_reg.h | |||
@@ -323,6 +323,7 @@ | |||
323 | #define UART_OMAP_MVER 0x14 /* Module version register */ | 323 | #define UART_OMAP_MVER 0x14 /* Module version register */ |
324 | #define UART_OMAP_SYSC 0x15 /* System configuration register */ | 324 | #define UART_OMAP_SYSC 0x15 /* System configuration register */ |
325 | #define UART_OMAP_SYSS 0x16 /* System status register */ | 325 | #define UART_OMAP_SYSS 0x16 /* System status register */ |
326 | #define UART_OMAP_WER 0x17 /* Wake-up enable register */ | ||
326 | 327 | ||
327 | #endif /* _LINUX_SERIAL_REG_H */ | 328 | #endif /* _LINUX_SERIAL_REG_H */ |
328 | 329 | ||
diff --git a/include/linux/serio.h b/include/linux/serio.h index e0417e4d3f15..126d24c9eaa8 100644 --- a/include/linux/serio.h +++ b/include/linux/serio.h | |||
@@ -15,6 +15,7 @@ | |||
15 | 15 | ||
16 | #ifdef __KERNEL__ | 16 | #ifdef __KERNEL__ |
17 | 17 | ||
18 | #include <linux/types.h> | ||
18 | #include <linux/interrupt.h> | 19 | #include <linux/interrupt.h> |
19 | #include <linux/list.h> | 20 | #include <linux/list.h> |
20 | #include <linux/spinlock.h> | 21 | #include <linux/spinlock.h> |
@@ -28,7 +29,10 @@ struct serio { | |||
28 | char name[32]; | 29 | char name[32]; |
29 | char phys[32]; | 30 | char phys[32]; |
30 | 31 | ||
31 | unsigned int manual_bind; | 32 | bool manual_bind; |
33 | bool registered; /* port has been fully registered with driver core */ | ||
34 | bool suspended; /* port is suspended */ | ||
35 | |||
32 | 36 | ||
33 | struct serio_device_id id; | 37 | struct serio_device_id id; |
34 | 38 | ||
@@ -47,7 +51,6 @@ struct serio { | |||
47 | struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */ | 51 | struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */ |
48 | 52 | ||
49 | struct device dev; | 53 | struct device dev; |
50 | unsigned int registered; /* port has been fully registered with driver core */ | ||
51 | 54 | ||
52 | struct list_head node; | 55 | struct list_head node; |
53 | }; | 56 | }; |
@@ -58,7 +61,7 @@ struct serio_driver { | |||
58 | char *description; | 61 | char *description; |
59 | 62 | ||
60 | struct serio_device_id *id_table; | 63 | struct serio_device_id *id_table; |
61 | unsigned int manual_bind; | 64 | bool manual_bind; |
62 | 65 | ||
63 | void (*write_wakeup)(struct serio *); | 66 | void (*write_wakeup)(struct serio *); |
64 | irqreturn_t (*interrupt)(struct serio *, unsigned char, unsigned int); | 67 | irqreturn_t (*interrupt)(struct serio *, unsigned char, unsigned int); |
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h index fd83f2584b15..abff6c9b413c 100644 --- a/include/linux/shmem_fs.h +++ b/include/linux/shmem_fs.h | |||
@@ -19,10 +19,6 @@ struct shmem_inode_info { | |||
19 | swp_entry_t i_direct[SHMEM_NR_DIRECT]; /* first blocks */ | 19 | swp_entry_t i_direct[SHMEM_NR_DIRECT]; /* first blocks */ |
20 | struct list_head swaplist; /* chain of maybes on swap */ | 20 | struct list_head swaplist; /* chain of maybes on swap */ |
21 | struct inode vfs_inode; | 21 | struct inode vfs_inode; |
22 | #ifdef CONFIG_TMPFS_POSIX_ACL | ||
23 | struct posix_acl *i_acl; | ||
24 | struct posix_acl *i_default_acl; | ||
25 | #endif | ||
26 | }; | 22 | }; |
27 | 23 | ||
28 | struct shmem_sb_info { | 24 | struct shmem_sb_info { |
@@ -45,7 +41,6 @@ static inline struct shmem_inode_info *SHMEM_I(struct inode *inode) | |||
45 | #ifdef CONFIG_TMPFS_POSIX_ACL | 41 | #ifdef CONFIG_TMPFS_POSIX_ACL |
46 | int shmem_permission(struct inode *, int); | 42 | int shmem_permission(struct inode *, int); |
47 | int shmem_acl_init(struct inode *, struct inode *); | 43 | int shmem_acl_init(struct inode *, struct inode *); |
48 | void shmem_acl_destroy_inode(struct inode *); | ||
49 | 44 | ||
50 | extern struct xattr_handler shmem_xattr_acl_access_handler; | 45 | extern struct xattr_handler shmem_xattr_acl_access_handler; |
51 | extern struct xattr_handler shmem_xattr_acl_default_handler; | 46 | extern struct xattr_handler shmem_xattr_acl_default_handler; |
@@ -57,9 +52,6 @@ static inline int shmem_acl_init(struct inode *inode, struct inode *dir) | |||
57 | { | 52 | { |
58 | return 0; | 53 | return 0; |
59 | } | 54 | } |
60 | static inline void shmem_acl_destroy_inode(struct inode *inode) | ||
61 | { | ||
62 | } | ||
63 | #endif /* CONFIG_TMPFS_POSIX_ACL */ | 55 | #endif /* CONFIG_TMPFS_POSIX_ACL */ |
64 | 56 | ||
65 | #endif | 57 | #endif |
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h index 2ea20320c093..51948eb6927a 100644 --- a/include/linux/spi/ads7846.h +++ b/include/linux/spi/ads7846.h | |||
@@ -17,6 +17,7 @@ struct ads7846_platform_data { | |||
17 | u16 vref_mv; /* external vref value, milliVolts */ | 17 | u16 vref_mv; /* external vref value, milliVolts */ |
18 | bool keep_vref_on; /* set to keep vref on for differential | 18 | bool keep_vref_on; /* set to keep vref on for differential |
19 | * measurements as well */ | 19 | * measurements as well */ |
20 | bool swap_xy; /* swap x and y axes */ | ||
20 | 21 | ||
21 | /* Settling time of the analog signals; a function of Vcc and the | 22 | /* Settling time of the analog signals; a function of Vcc and the |
22 | * capacitance on the X/Y drivers. If set to non-zero, two samples | 23 | * capacitance on the X/Y drivers. If set to non-zero, two samples |
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h new file mode 100644 index 000000000000..6508f0dc0eff --- /dev/null +++ b/include/linux/sunrpc/bc_xprt.h | |||
@@ -0,0 +1,49 @@ | |||
1 | /****************************************************************************** | ||
2 | |||
3 | (c) 2008 NetApp. All Rights Reserved. | ||
4 | |||
5 | NetApp provides this source code under the GPL v2 License. | ||
6 | The GPL v2 license is available at | ||
7 | http://opensource.org/licenses/gpl-license.php. | ||
8 | |||
9 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
10 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
11 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
12 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
13 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
14 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
15 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
16 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
17 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
18 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
19 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
20 | |||
21 | ******************************************************************************/ | ||
22 | |||
23 | /* | ||
24 | * Functions to create and manage the backchannel | ||
25 | */ | ||
26 | |||
27 | #ifndef _LINUX_SUNRPC_BC_XPRT_H | ||
28 | #define _LINUX_SUNRPC_BC_XPRT_H | ||
29 | |||
30 | #include <linux/sunrpc/svcsock.h> | ||
31 | #include <linux/sunrpc/xprt.h> | ||
32 | #include <linux/sunrpc/sched.h> | ||
33 | |||
34 | #ifdef CONFIG_NFS_V4_1 | ||
35 | struct rpc_rqst *xprt_alloc_bc_request(struct rpc_xprt *xprt); | ||
36 | void xprt_free_bc_request(struct rpc_rqst *req); | ||
37 | int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs); | ||
38 | void xprt_destroy_backchannel(struct rpc_xprt *, int max_reqs); | ||
39 | void bc_release_request(struct rpc_task *); | ||
40 | int bc_send(struct rpc_rqst *req); | ||
41 | #else /* CONFIG_NFS_V4_1 */ | ||
42 | static inline int xprt_setup_backchannel(struct rpc_xprt *xprt, | ||
43 | unsigned int min_reqs) | ||
44 | { | ||
45 | return 0; | ||
46 | } | ||
47 | #endif /* CONFIG_NFS_V4_1 */ | ||
48 | #endif /* _LINUX_SUNRPC_BC_XPRT_H */ | ||
49 | |||
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h index c39a21040dcb..37881f1a0bd7 100644 --- a/include/linux/sunrpc/clnt.h +++ b/include/linux/sunrpc/clnt.h | |||
@@ -143,6 +143,7 @@ int rpc_call_sync(struct rpc_clnt *clnt, | |||
143 | const struct rpc_message *msg, int flags); | 143 | const struct rpc_message *msg, int flags); |
144 | struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, | 144 | struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, |
145 | int flags); | 145 | int flags); |
146 | void rpc_restart_call_prepare(struct rpc_task *); | ||
146 | void rpc_restart_call(struct rpc_task *); | 147 | void rpc_restart_call(struct rpc_task *); |
147 | void rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int); | 148 | void rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int); |
148 | size_t rpc_max_payload(struct rpc_clnt *); | 149 | size_t rpc_max_payload(struct rpc_clnt *); |
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h index 64981a2f1cae..401097781fc0 100644 --- a/include/linux/sunrpc/sched.h +++ b/include/linux/sunrpc/sched.h | |||
@@ -210,6 +210,8 @@ struct rpc_wait_queue { | |||
210 | */ | 210 | */ |
211 | struct rpc_task *rpc_new_task(const struct rpc_task_setup *); | 211 | struct rpc_task *rpc_new_task(const struct rpc_task_setup *); |
212 | struct rpc_task *rpc_run_task(const struct rpc_task_setup *); | 212 | struct rpc_task *rpc_run_task(const struct rpc_task_setup *); |
213 | struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req, | ||
214 | const struct rpc_call_ops *ops); | ||
213 | void rpc_put_task(struct rpc_task *); | 215 | void rpc_put_task(struct rpc_task *); |
214 | void rpc_exit_task(struct rpc_task *); | 216 | void rpc_exit_task(struct rpc_task *); |
215 | void rpc_release_calldata(const struct rpc_call_ops *, void *); | 217 | void rpc_release_calldata(const struct rpc_call_ops *, void *); |
@@ -237,6 +239,7 @@ void rpc_show_tasks(void); | |||
237 | int rpc_init_mempool(void); | 239 | int rpc_init_mempool(void); |
238 | void rpc_destroy_mempool(void); | 240 | void rpc_destroy_mempool(void); |
239 | extern struct workqueue_struct *rpciod_workqueue; | 241 | extern struct workqueue_struct *rpciod_workqueue; |
242 | void rpc_prepare_task(struct rpc_task *task); | ||
240 | 243 | ||
241 | static inline void rpc_exit(struct rpc_task *task, int status) | 244 | static inline void rpc_exit(struct rpc_task *task, int status) |
242 | { | 245 | { |
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h index 2a30775959e9..ea8009695c69 100644 --- a/include/linux/sunrpc/svc.h +++ b/include/linux/sunrpc/svc.h | |||
@@ -96,6 +96,15 @@ struct svc_serv { | |||
96 | svc_thread_fn sv_function; /* main function for threads */ | 96 | svc_thread_fn sv_function; /* main function for threads */ |
97 | unsigned int sv_drc_max_pages; /* Total pages for DRC */ | 97 | unsigned int sv_drc_max_pages; /* Total pages for DRC */ |
98 | unsigned int sv_drc_pages_used;/* DRC pages used */ | 98 | unsigned int sv_drc_pages_used;/* DRC pages used */ |
99 | #if defined(CONFIG_NFS_V4_1) | ||
100 | struct list_head sv_cb_list; /* queue for callback requests | ||
101 | * that arrive over the same | ||
102 | * connection */ | ||
103 | spinlock_t sv_cb_lock; /* protects the svc_cb_list */ | ||
104 | wait_queue_head_t sv_cb_waitq; /* sleep here if there are no | ||
105 | * entries in the svc_cb_list */ | ||
106 | struct svc_xprt *bc_xprt; | ||
107 | #endif /* CONFIG_NFS_V4_1 */ | ||
99 | }; | 108 | }; |
100 | 109 | ||
101 | /* | 110 | /* |
@@ -411,6 +420,8 @@ int svc_set_num_threads(struct svc_serv *, struct svc_pool *, int); | |||
411 | int svc_pool_stats_open(struct svc_serv *serv, struct file *file); | 420 | int svc_pool_stats_open(struct svc_serv *serv, struct file *file); |
412 | void svc_destroy(struct svc_serv *); | 421 | void svc_destroy(struct svc_serv *); |
413 | int svc_process(struct svc_rqst *); | 422 | int svc_process(struct svc_rqst *); |
423 | int bc_svc_process(struct svc_serv *, struct rpc_rqst *, | ||
424 | struct svc_rqst *); | ||
414 | int svc_register(const struct svc_serv *, const int, | 425 | int svc_register(const struct svc_serv *, const int, |
415 | const unsigned short, const unsigned short); | 426 | const unsigned short, const unsigned short); |
416 | 427 | ||
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h index 0d9cb6ef28b0..2223ae0b5ed5 100644 --- a/include/linux/sunrpc/svc_xprt.h +++ b/include/linux/sunrpc/svc_xprt.h | |||
@@ -83,7 +83,7 @@ int svc_port_is_privileged(struct sockaddr *sin); | |||
83 | int svc_print_xprts(char *buf, int maxlen); | 83 | int svc_print_xprts(char *buf, int maxlen); |
84 | struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name, | 84 | struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name, |
85 | const sa_family_t af, const unsigned short port); | 85 | const sa_family_t af, const unsigned short port); |
86 | int svc_xprt_names(struct svc_serv *serv, char *buf, int buflen); | 86 | int svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen); |
87 | 87 | ||
88 | static inline void svc_xprt_get(struct svc_xprt *xprt) | 88 | static inline void svc_xprt_get(struct svc_xprt *xprt) |
89 | { | 89 | { |
@@ -118,7 +118,7 @@ static inline unsigned short svc_addr_port(const struct sockaddr *sa) | |||
118 | return 0; | 118 | return 0; |
119 | } | 119 | } |
120 | 120 | ||
121 | static inline size_t svc_addr_len(struct sockaddr *sa) | 121 | static inline size_t svc_addr_len(const struct sockaddr *sa) |
122 | { | 122 | { |
123 | switch (sa->sa_family) { | 123 | switch (sa->sa_family) { |
124 | case AF_INET: | 124 | case AF_INET: |
@@ -126,7 +126,8 @@ static inline size_t svc_addr_len(struct sockaddr *sa) | |||
126 | case AF_INET6: | 126 | case AF_INET6: |
127 | return sizeof(struct sockaddr_in6); | 127 | return sizeof(struct sockaddr_in6); |
128 | } | 128 | } |
129 | return -EAFNOSUPPORT; | 129 | |
130 | return 0; | ||
130 | } | 131 | } |
131 | 132 | ||
132 | static inline unsigned short svc_xprt_local_port(const struct svc_xprt *xprt) | 133 | static inline unsigned short svc_xprt_local_port(const struct svc_xprt *xprt) |
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h index 483e10380aae..04dba23c59f2 100644 --- a/include/linux/sunrpc/svcsock.h +++ b/include/linux/sunrpc/svcsock.h | |||
@@ -38,10 +38,15 @@ int svc_recv(struct svc_rqst *, long); | |||
38 | int svc_send(struct svc_rqst *); | 38 | int svc_send(struct svc_rqst *); |
39 | void svc_drop(struct svc_rqst *); | 39 | void svc_drop(struct svc_rqst *); |
40 | void svc_sock_update_bufs(struct svc_serv *serv); | 40 | void svc_sock_update_bufs(struct svc_serv *serv); |
41 | int svc_sock_names(char *buf, struct svc_serv *serv, char *toclose); | 41 | int svc_sock_names(struct svc_serv *serv, char *buf, |
42 | int svc_addsock(struct svc_serv *serv, int fd, char *name_return); | 42 | const size_t buflen, |
43 | const char *toclose); | ||
44 | int svc_addsock(struct svc_serv *serv, const int fd, | ||
45 | char *name_return, const size_t len); | ||
43 | void svc_init_xprt_sock(void); | 46 | void svc_init_xprt_sock(void); |
44 | void svc_cleanup_xprt_sock(void); | 47 | void svc_cleanup_xprt_sock(void); |
48 | struct svc_xprt *svc_sock_create(struct svc_serv *serv, int prot); | ||
49 | void svc_sock_destroy(struct svc_xprt *); | ||
45 | 50 | ||
46 | /* | 51 | /* |
47 | * svc_makesock socket characteristics | 52 | * svc_makesock socket characteristics |
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h index 08afe43118f4..1175d58efc2e 100644 --- a/include/linux/sunrpc/xprt.h +++ b/include/linux/sunrpc/xprt.h | |||
@@ -67,7 +67,8 @@ struct rpc_rqst { | |||
67 | struct rpc_task * rq_task; /* RPC task data */ | 67 | struct rpc_task * rq_task; /* RPC task data */ |
68 | __be32 rq_xid; /* request XID */ | 68 | __be32 rq_xid; /* request XID */ |
69 | int rq_cong; /* has incremented xprt->cong */ | 69 | int rq_cong; /* has incremented xprt->cong */ |
70 | int rq_received; /* receive completed */ | 70 | int rq_reply_bytes_recvd; /* number of reply */ |
71 | /* bytes received */ | ||
71 | u32 rq_seqno; /* gss seq no. used on req. */ | 72 | u32 rq_seqno; /* gss seq no. used on req. */ |
72 | int rq_enc_pages_num; | 73 | int rq_enc_pages_num; |
73 | struct page **rq_enc_pages; /* scratch pages for use by | 74 | struct page **rq_enc_pages; /* scratch pages for use by |
@@ -97,6 +98,12 @@ struct rpc_rqst { | |||
97 | 98 | ||
98 | unsigned long rq_xtime; /* when transmitted */ | 99 | unsigned long rq_xtime; /* when transmitted */ |
99 | int rq_ntrans; | 100 | int rq_ntrans; |
101 | |||
102 | #if defined(CONFIG_NFS_V4_1) | ||
103 | struct list_head rq_bc_list; /* Callback service list */ | ||
104 | unsigned long rq_bc_pa_state; /* Backchannel prealloc state */ | ||
105 | struct list_head rq_bc_pa_list; /* Backchannel prealloc list */ | ||
106 | #endif /* CONFIG_NFS_V4_1 */ | ||
100 | }; | 107 | }; |
101 | #define rq_svec rq_snd_buf.head | 108 | #define rq_svec rq_snd_buf.head |
102 | #define rq_slen rq_snd_buf.len | 109 | #define rq_slen rq_snd_buf.len |
@@ -174,6 +181,15 @@ struct rpc_xprt { | |||
174 | spinlock_t reserve_lock; /* lock slot table */ | 181 | spinlock_t reserve_lock; /* lock slot table */ |
175 | u32 xid; /* Next XID value to use */ | 182 | u32 xid; /* Next XID value to use */ |
176 | struct rpc_task * snd_task; /* Task blocked in send */ | 183 | struct rpc_task * snd_task; /* Task blocked in send */ |
184 | #if defined(CONFIG_NFS_V4_1) | ||
185 | struct svc_serv *bc_serv; /* The RPC service which will */ | ||
186 | /* process the callback */ | ||
187 | unsigned int bc_alloc_count; /* Total number of preallocs */ | ||
188 | spinlock_t bc_pa_lock; /* Protects the preallocated | ||
189 | * items */ | ||
190 | struct list_head bc_pa_list; /* List of preallocated | ||
191 | * backchannel rpc_rqst's */ | ||
192 | #endif /* CONFIG_NFS_V4_1 */ | ||
177 | struct list_head recv; | 193 | struct list_head recv; |
178 | 194 | ||
179 | struct { | 195 | struct { |
@@ -192,6 +208,26 @@ struct rpc_xprt { | |||
192 | const char *address_strings[RPC_DISPLAY_MAX]; | 208 | const char *address_strings[RPC_DISPLAY_MAX]; |
193 | }; | 209 | }; |
194 | 210 | ||
211 | #if defined(CONFIG_NFS_V4_1) | ||
212 | /* | ||
213 | * Backchannel flags | ||
214 | */ | ||
215 | #define RPC_BC_PA_IN_USE 0x0001 /* Preallocated backchannel */ | ||
216 | /* buffer in use */ | ||
217 | #endif /* CONFIG_NFS_V4_1 */ | ||
218 | |||
219 | #if defined(CONFIG_NFS_V4_1) | ||
220 | static inline int bc_prealloc(struct rpc_rqst *req) | ||
221 | { | ||
222 | return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state); | ||
223 | } | ||
224 | #else | ||
225 | static inline int bc_prealloc(struct rpc_rqst *req) | ||
226 | { | ||
227 | return 0; | ||
228 | } | ||
229 | #endif /* CONFIG_NFS_V4_1 */ | ||
230 | |||
195 | struct xprt_create { | 231 | struct xprt_create { |
196 | int ident; /* XPRT_TRANSPORT identifier */ | 232 | int ident; /* XPRT_TRANSPORT identifier */ |
197 | struct sockaddr * srcaddr; /* optional local address */ | 233 | struct sockaddr * srcaddr; /* optional local address */ |
diff --git a/include/linux/swap.h b/include/linux/swap.h index c88b36665f79..7c15334f3ff2 100644 --- a/include/linux/swap.h +++ b/include/linux/swap.h | |||
@@ -298,8 +298,8 @@ extern int try_to_free_swap(struct page *); | |||
298 | struct backing_dev_info; | 298 | struct backing_dev_info; |
299 | 299 | ||
300 | /* linux/mm/thrash.c */ | 300 | /* linux/mm/thrash.c */ |
301 | extern struct mm_struct * swap_token_mm; | 301 | extern struct mm_struct *swap_token_mm; |
302 | extern void grab_swap_token(void); | 302 | extern void grab_swap_token(struct mm_struct *); |
303 | extern void __put_swap_token(struct mm_struct *); | 303 | extern void __put_swap_token(struct mm_struct *); |
304 | 304 | ||
305 | static inline int has_swap_token(struct mm_struct *mm) | 305 | static inline int has_swap_token(struct mm_struct *mm) |
@@ -419,10 +419,10 @@ static inline swp_entry_t get_swap_page(void) | |||
419 | } | 419 | } |
420 | 420 | ||
421 | /* linux/mm/thrash.c */ | 421 | /* linux/mm/thrash.c */ |
422 | #define put_swap_token(x) do { } while(0) | 422 | #define put_swap_token(mm) do { } while (0) |
423 | #define grab_swap_token() do { } while(0) | 423 | #define grab_swap_token(mm) do { } while (0) |
424 | #define has_swap_token(x) 0 | 424 | #define has_swap_token(mm) 0 |
425 | #define disable_swap_token() do { } while(0) | 425 | #define disable_swap_token() do { } while (0) |
426 | 426 | ||
427 | static inline void | 427 | static inline void |
428 | mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent) | 428 | mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent) |
diff --git a/include/linux/timer.h b/include/linux/timer.h index ccf882eed8f8..be62ec2ebea5 100644 --- a/include/linux/timer.h +++ b/include/linux/timer.h | |||
@@ -190,6 +190,8 @@ extern unsigned long get_next_timer_interrupt(unsigned long now); | |||
190 | */ | 190 | */ |
191 | #ifdef CONFIG_TIMER_STATS | 191 | #ifdef CONFIG_TIMER_STATS |
192 | 192 | ||
193 | extern int timer_stats_active; | ||
194 | |||
193 | #define TIMER_STATS_FLAG_DEFERRABLE 0x1 | 195 | #define TIMER_STATS_FLAG_DEFERRABLE 0x1 |
194 | 196 | ||
195 | extern void init_timer_stats(void); | 197 | extern void init_timer_stats(void); |
@@ -203,6 +205,8 @@ extern void __timer_stats_timer_set_start_info(struct timer_list *timer, | |||
203 | 205 | ||
204 | static inline void timer_stats_timer_set_start_info(struct timer_list *timer) | 206 | static inline void timer_stats_timer_set_start_info(struct timer_list *timer) |
205 | { | 207 | { |
208 | if (likely(!timer_stats_active)) | ||
209 | return; | ||
206 | __timer_stats_timer_set_start_info(timer, __builtin_return_address(0)); | 210 | __timer_stats_timer_set_start_info(timer, __builtin_return_address(0)); |
207 | } | 211 | } |
208 | 212 | ||
diff --git a/include/linux/trace_seq.h b/include/linux/trace_seq.h index c68bccba2074..c134dd1fe6b6 100644 --- a/include/linux/trace_seq.h +++ b/include/linux/trace_seq.h | |||
@@ -3,6 +3,8 @@ | |||
3 | 3 | ||
4 | #include <linux/fs.h> | 4 | #include <linux/fs.h> |
5 | 5 | ||
6 | #include <asm/page.h> | ||
7 | |||
6 | /* | 8 | /* |
7 | * Trace sequences are used to allow a function to call several other functions | 9 | * Trace sequences are used to allow a function to call several other functions |
8 | * to create a string of data to use (up to a max of PAGE_SIZE. | 10 | * to create a string of data to use (up to a max of PAGE_SIZE. |
diff --git a/include/linux/types.h b/include/linux/types.h index 5abe354020f9..c42724f8c802 100644 --- a/include/linux/types.h +++ b/include/linux/types.h | |||
@@ -131,7 +131,7 @@ typedef __s64 int64_t; | |||
131 | * | 131 | * |
132 | * blkcnt_t is the type of the inode's block count. | 132 | * blkcnt_t is the type of the inode's block count. |
133 | */ | 133 | */ |
134 | #ifdef CONFIG_LBD | 134 | #ifdef CONFIG_LBDAF |
135 | typedef u64 sector_t; | 135 | typedef u64 sector_t; |
136 | typedef u64 blkcnt_t; | 136 | typedef u64 blkcnt_t; |
137 | #else | 137 | #else |
diff --git a/include/linux/ucb1400.h b/include/linux/ucb1400.h index 970473bf8d5a..ed889f4168f3 100644 --- a/include/linux/ucb1400.h +++ b/include/linux/ucb1400.h | |||
@@ -134,28 +134,13 @@ static inline void ucb1400_adc_enable(struct snd_ac97 *ac97) | |||
134 | ucb1400_reg_write(ac97, UCB_ADC_CR, UCB_ADC_ENA); | 134 | ucb1400_reg_write(ac97, UCB_ADC_CR, UCB_ADC_ENA); |
135 | } | 135 | } |
136 | 136 | ||
137 | static unsigned int ucb1400_adc_read(struct snd_ac97 *ac97, u16 adc_channel, | ||
138 | int adcsync) | ||
139 | { | ||
140 | unsigned int val; | ||
141 | |||
142 | if (adcsync) | ||
143 | adc_channel |= UCB_ADC_SYNC_ENA; | ||
144 | |||
145 | ucb1400_reg_write(ac97, UCB_ADC_CR, UCB_ADC_ENA | adc_channel); | ||
146 | ucb1400_reg_write(ac97, UCB_ADC_CR, UCB_ADC_ENA | adc_channel | | ||
147 | UCB_ADC_START); | ||
148 | |||
149 | while (!((val = ucb1400_reg_read(ac97, UCB_ADC_DATA)) | ||
150 | & UCB_ADC_DAT_VALID)) | ||
151 | schedule_timeout_uninterruptible(1); | ||
152 | |||
153 | return val & UCB_ADC_DAT_MASK; | ||
154 | } | ||
155 | |||
156 | static inline void ucb1400_adc_disable(struct snd_ac97 *ac97) | 137 | static inline void ucb1400_adc_disable(struct snd_ac97 *ac97) |
157 | { | 138 | { |
158 | ucb1400_reg_write(ac97, UCB_ADC_CR, 0); | 139 | ucb1400_reg_write(ac97, UCB_ADC_CR, 0); |
159 | } | 140 | } |
160 | 141 | ||
142 | |||
143 | unsigned int ucb1400_adc_read(struct snd_ac97 *ac97, u16 adc_channel, | ||
144 | int adcsync); | ||
145 | |||
161 | #endif | 146 | #endif |
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h index f24eceecc5a6..8a025d510904 100644 --- a/include/linux/videodev2.h +++ b/include/linux/videodev2.h | |||
@@ -348,6 +348,7 @@ struct v4l2_pix_format { | |||
348 | #define V4L2_PIX_FMT_SQ905C v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */ | 348 | #define V4L2_PIX_FMT_SQ905C v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */ |
349 | #define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */ | 349 | #define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */ |
350 | #define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */ | 350 | #define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */ |
351 | #define V4L2_PIX_FMT_OV511 v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */ | ||
351 | #define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */ | 352 | #define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */ |
352 | 353 | ||
353 | /* | 354 | /* |
@@ -894,9 +895,10 @@ enum v4l2_colorfx { | |||
894 | V4L2_COLORFX_BW = 1, | 895 | V4L2_COLORFX_BW = 1, |
895 | V4L2_COLORFX_SEPIA = 2, | 896 | V4L2_COLORFX_SEPIA = 2, |
896 | }; | 897 | }; |
898 | #define V4L2_CID_AUTOBRIGHTNESS (V4L2_CID_BASE+32) | ||
897 | 899 | ||
898 | /* last CID + 1 */ | 900 | /* last CID + 1 */ |
899 | #define V4L2_CID_LASTP1 (V4L2_CID_BASE+32) | 901 | #define V4L2_CID_LASTP1 (V4L2_CID_BASE+33) |
900 | 902 | ||
901 | /* MPEG-class control IDs defined by V4L2 */ | 903 | /* MPEG-class control IDs defined by V4L2 */ |
902 | #define V4L2_CID_MPEG_BASE (V4L2_CTRL_CLASS_MPEG | 0x900) | 904 | #define V4L2_CID_MPEG_BASE (V4L2_CTRL_CLASS_MPEG | 0x900) |
diff --git a/include/media/ir-common.h b/include/media/ir-common.h index 7b5b91f60425..9dcb632f6083 100644 --- a/include/media/ir-common.h +++ b/include/media/ir-common.h | |||
@@ -162,6 +162,8 @@ extern IR_KEYTAB_TYPE ir_codes_ati_tv_wonder_hd_600[IR_KEYTAB_SIZE]; | |||
162 | extern IR_KEYTAB_TYPE ir_codes_kworld_plus_tv_analog[IR_KEYTAB_SIZE]; | 162 | extern IR_KEYTAB_TYPE ir_codes_kworld_plus_tv_analog[IR_KEYTAB_SIZE]; |
163 | extern IR_KEYTAB_TYPE ir_codes_kaiomy[IR_KEYTAB_SIZE]; | 163 | extern IR_KEYTAB_TYPE ir_codes_kaiomy[IR_KEYTAB_SIZE]; |
164 | extern IR_KEYTAB_TYPE ir_codes_dm1105_nec[IR_KEYTAB_SIZE]; | 164 | extern IR_KEYTAB_TYPE ir_codes_dm1105_nec[IR_KEYTAB_SIZE]; |
165 | extern IR_KEYTAB_TYPE ir_codes_evga_indtube[IR_KEYTAB_SIZE]; | ||
166 | |||
165 | #endif | 167 | #endif |
166 | 168 | ||
167 | /* | 169 | /* |
diff --git a/include/media/v4l2-common.h b/include/media/v4l2-common.h index c48c24e4d0fa..33a18426ab9b 100644 --- a/include/media/v4l2-common.h +++ b/include/media/v4l2-common.h | |||
@@ -153,6 +153,22 @@ struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev, | |||
153 | struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev, | 153 | struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev, |
154 | struct i2c_adapter *adapter, | 154 | struct i2c_adapter *adapter, |
155 | const char *module_name, const char *client_type, u8 addr); | 155 | const char *module_name, const char *client_type, u8 addr); |
156 | |||
157 | /* Load an i2c module and return an initialized v4l2_subdev struct. | ||
158 | Only call request_module if module_name != NULL. | ||
159 | The client_type argument is the name of the chip that's on the adapter. */ | ||
160 | struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev, | ||
161 | struct i2c_adapter *adapter, | ||
162 | const char *module_name, const char *client_type, | ||
163 | int irq, void *platform_data, | ||
164 | u8 addr, const unsigned short *probe_addrs); | ||
165 | |||
166 | struct i2c_board_info; | ||
167 | |||
168 | struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev, | ||
169 | struct i2c_adapter *adapter, const char *module_name, | ||
170 | struct i2c_board_info *info, const unsigned short *probe_addrs); | ||
171 | |||
156 | /* Initialize an v4l2_subdev with data from an i2c_client struct */ | 172 | /* Initialize an v4l2_subdev with data from an i2c_client struct */ |
157 | void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client, | 173 | void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client, |
158 | const struct v4l2_subdev_ops *ops); | 174 | const struct v4l2_subdev_ops *ops); |
@@ -193,4 +209,14 @@ struct v4l2_routing { | |||
193 | u32 output; | 209 | u32 output; |
194 | }; | 210 | }; |
195 | 211 | ||
212 | /* ------------------------------------------------------------------------- */ | ||
213 | |||
214 | /* Miscellaneous helper functions */ | ||
215 | |||
216 | void v4l_bound_align_image(unsigned int *w, unsigned int wmin, | ||
217 | unsigned int wmax, unsigned int walign, | ||
218 | unsigned int *h, unsigned int hmin, | ||
219 | unsigned int hmax, unsigned int halign, | ||
220 | unsigned int salign); | ||
221 | |||
196 | #endif /* V4L2_COMMON_H_ */ | 222 | #endif /* V4L2_COMMON_H_ */ |
diff --git a/include/media/v4l2-i2c-drv.h b/include/media/v4l2-i2c-drv.h index 10a2882c3cbf..74bf741d1a9b 100644 --- a/include/media/v4l2-i2c-drv.h +++ b/include/media/v4l2-i2c-drv.h | |||
@@ -22,7 +22,7 @@ | |||
22 | */ | 22 | */ |
23 | 23 | ||
24 | /* NOTE: the full version of this header is in the v4l-dvb repository | 24 | /* NOTE: the full version of this header is in the v4l-dvb repository |
25 | * and allows v4l i2c drivers to be compiled on older kernels as well. | 25 | * and allows v4l i2c drivers to be compiled on pre-2.6.26 kernels. |
26 | * The version of this header as it appears in the kernel is a stripped | 26 | * The version of this header as it appears in the kernel is a stripped |
27 | * version (without all the backwards compatibility stuff) and so it | 27 | * version (without all the backwards compatibility stuff) and so it |
28 | * looks a bit odd. | 28 | * looks a bit odd. |
@@ -30,6 +30,9 @@ | |||
30 | * If you look at the full version then you will understand the reason | 30 | * If you look at the full version then you will understand the reason |
31 | * for introducing this header since you really don't want to have all | 31 | * for introducing this header since you really don't want to have all |
32 | * the tricky backwards compatibility code in each and every i2c driver. | 32 | * the tricky backwards compatibility code in each and every i2c driver. |
33 | * | ||
34 | * If the i2c driver will never be compiled for pre-2.6.26 kernels, then | ||
35 | * DO NOT USE this header! Just write it as a regular i2c driver. | ||
33 | */ | 36 | */ |
34 | 37 | ||
35 | #ifndef __V4L2_I2C_DRV_H__ | 38 | #ifndef __V4L2_I2C_DRV_H__ |
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h index a503e1cee78b..5dcb36785529 100644 --- a/include/media/v4l2-subdev.h +++ b/include/media/v4l2-subdev.h | |||
@@ -79,7 +79,11 @@ struct v4l2_decode_vbi_line { | |||
79 | not yet implemented) since ops provide proper type-checking. | 79 | not yet implemented) since ops provide proper type-checking. |
80 | */ | 80 | */ |
81 | 81 | ||
82 | /* init: initialize the sensor registors to some sort of reasonable default | 82 | /* s_config: if set, then it is always called by the v4l2_i2c_new_subdev* |
83 | functions after the v4l2_subdev was registered. It is used to pass | ||
84 | platform data to the subdev which can be used during initialization. | ||
85 | |||
86 | init: initialize the sensor registors to some sort of reasonable default | ||
83 | values. Do not use for new drivers and should be removed in existing | 87 | values. Do not use for new drivers and should be removed in existing |
84 | drivers. | 88 | drivers. |
85 | 89 | ||
@@ -96,6 +100,7 @@ struct v4l2_decode_vbi_line { | |||
96 | struct v4l2_subdev_core_ops { | 100 | struct v4l2_subdev_core_ops { |
97 | int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip); | 101 | int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip); |
98 | int (*log_status)(struct v4l2_subdev *sd); | 102 | int (*log_status)(struct v4l2_subdev *sd); |
103 | int (*s_config)(struct v4l2_subdev *sd, int irq, void *platform_data); | ||
99 | int (*init)(struct v4l2_subdev *sd, u32 val); | 104 | int (*init)(struct v4l2_subdev *sd, u32 val); |
100 | int (*load_fw)(struct v4l2_subdev *sd); | 105 | int (*load_fw)(struct v4l2_subdev *sd); |
101 | int (*reset)(struct v4l2_subdev *sd, u32 val); | 106 | int (*reset)(struct v4l2_subdev *sd, u32 val); |
diff --git a/include/mtd/Kbuild b/include/mtd/Kbuild index 8eb018f96002..192f8fb7d546 100644 --- a/include/mtd/Kbuild +++ b/include/mtd/Kbuild | |||
@@ -1,5 +1,4 @@ | |||
1 | header-y += inftl-user.h | 1 | header-y += inftl-user.h |
2 | header-y += jffs2-user.h | ||
3 | header-y += mtd-abi.h | 2 | header-y += mtd-abi.h |
4 | header-y += mtd-user.h | 3 | header-y += mtd-user.h |
5 | header-y += nftl-user.h | 4 | header-y += nftl-user.h |
diff --git a/include/mtd/jffs2-user.h b/include/mtd/jffs2-user.h deleted file mode 100644 index fa94b0eb67c1..000000000000 --- a/include/mtd/jffs2-user.h +++ /dev/null | |||
@@ -1,34 +0,0 @@ | |||
1 | /* | ||
2 | * JFFS2 definitions for use in user space only | ||
3 | */ | ||
4 | |||
5 | #ifndef __JFFS2_USER_H__ | ||
6 | #define __JFFS2_USER_H__ | ||
7 | |||
8 | /* This file is blessed for inclusion by userspace */ | ||
9 | #include <linux/jffs2.h> | ||
10 | #include <linux/types.h> | ||
11 | #include <endian.h> | ||
12 | #include <byteswap.h> | ||
13 | |||
14 | #undef cpu_to_je16 | ||
15 | #undef cpu_to_je32 | ||
16 | #undef cpu_to_jemode | ||
17 | #undef je16_to_cpu | ||
18 | #undef je32_to_cpu | ||
19 | #undef jemode_to_cpu | ||
20 | |||
21 | extern int target_endian; | ||
22 | |||
23 | #define t16(x) ({ __u16 __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_16(__b); }) | ||
24 | #define t32(x) ({ __u32 __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_32(__b); }) | ||
25 | |||
26 | #define cpu_to_je16(x) ((jint16_t){t16(x)}) | ||
27 | #define cpu_to_je32(x) ((jint32_t){t32(x)}) | ||
28 | #define cpu_to_jemode(x) ((jmode_t){t32(x)}) | ||
29 | |||
30 | #define je16_to_cpu(x) (t16((x).v16)) | ||
31 | #define je32_to_cpu(x) (t32((x).v32)) | ||
32 | #define jemode_to_cpu(x) (t32((x).m)) | ||
33 | |||
34 | #endif /* __JFFS2_USER_H__ */ | ||
diff --git a/include/mtd/mtd-abi.h b/include/mtd/mtd-abi.h index b6595b3c68b6..be51ae2bd0ff 100644 --- a/include/mtd/mtd-abi.h +++ b/include/mtd/mtd-abi.h | |||
@@ -12,12 +12,24 @@ struct erase_info_user { | |||
12 | __u32 length; | 12 | __u32 length; |
13 | }; | 13 | }; |
14 | 14 | ||
15 | struct erase_info_user64 { | ||
16 | __u64 start; | ||
17 | __u64 length; | ||
18 | }; | ||
19 | |||
15 | struct mtd_oob_buf { | 20 | struct mtd_oob_buf { |
16 | __u32 start; | 21 | __u32 start; |
17 | __u32 length; | 22 | __u32 length; |
18 | unsigned char __user *ptr; | 23 | unsigned char __user *ptr; |
19 | }; | 24 | }; |
20 | 25 | ||
26 | struct mtd_oob_buf64 { | ||
27 | __u64 start; | ||
28 | __u32 pad; | ||
29 | __u32 length; | ||
30 | __u64 usr_ptr; | ||
31 | }; | ||
32 | |||
21 | #define MTD_ABSENT 0 | 33 | #define MTD_ABSENT 0 |
22 | #define MTD_RAM 1 | 34 | #define MTD_RAM 1 |
23 | #define MTD_ROM 2 | 35 | #define MTD_ROM 2 |
@@ -95,6 +107,9 @@ struct otp_info { | |||
95 | #define ECCGETLAYOUT _IOR('M', 17, struct nand_ecclayout) | 107 | #define ECCGETLAYOUT _IOR('M', 17, struct nand_ecclayout) |
96 | #define ECCGETSTATS _IOR('M', 18, struct mtd_ecc_stats) | 108 | #define ECCGETSTATS _IOR('M', 18, struct mtd_ecc_stats) |
97 | #define MTDFILEMODE _IO('M', 19) | 109 | #define MTDFILEMODE _IO('M', 19) |
110 | #define MEMERASE64 _IOW('M', 20, struct erase_info_user64) | ||
111 | #define MEMWRITEOOB64 _IOWR('M', 21, struct mtd_oob_buf64) | ||
112 | #define MEMREADOOB64 _IOWR('M', 22, struct mtd_oob_buf64) | ||
98 | 113 | ||
99 | /* | 114 | /* |
100 | * Obsolete legacy interface. Keep it in order not to break userspace | 115 | * Obsolete legacy interface. Keep it in order not to break userspace |
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h index 21ee49ffcbaf..f82a1e877372 100644 --- a/include/net/iucv/af_iucv.h +++ b/include/net/iucv/af_iucv.h | |||
@@ -94,8 +94,6 @@ unsigned int iucv_sock_poll(struct file *file, struct socket *sock, | |||
94 | poll_table *wait); | 94 | poll_table *wait); |
95 | void iucv_sock_link(struct iucv_sock_list *l, struct sock *s); | 95 | void iucv_sock_link(struct iucv_sock_list *l, struct sock *s); |
96 | void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *s); | 96 | void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *s); |
97 | int iucv_sock_wait_state(struct sock *sk, int state, int state2, | ||
98 | unsigned long timeo); | ||
99 | int iucv_sock_wait_cnt(struct sock *sk, unsigned long timeo); | 97 | int iucv_sock_wait_cnt(struct sock *sk, unsigned long timeo); |
100 | void iucv_accept_enqueue(struct sock *parent, struct sock *sk); | 98 | void iucv_accept_enqueue(struct sock *parent, struct sock *sk); |
101 | void iucv_accept_unlink(struct sock *sk); | 99 | void iucv_accept_unlink(struct sock *sk); |
diff --git a/include/net/phonet/pn_dev.h b/include/net/phonet/pn_dev.h index 5054dc5ea2c2..29d126736611 100644 --- a/include/net/phonet/pn_dev.h +++ b/include/net/phonet/pn_dev.h | |||
@@ -45,6 +45,7 @@ int phonet_address_add(struct net_device *dev, u8 addr); | |||
45 | int phonet_address_del(struct net_device *dev, u8 addr); | 45 | int phonet_address_del(struct net_device *dev, u8 addr); |
46 | u8 phonet_address_get(struct net_device *dev, u8 addr); | 46 | u8 phonet_address_get(struct net_device *dev, u8 addr); |
47 | int phonet_address_lookup(struct net *net, u8 addr); | 47 | int phonet_address_lookup(struct net *net, u8 addr); |
48 | void phonet_address_notify(int event, struct net_device *dev, u8 addr); | ||
48 | 49 | ||
49 | #define PN_NO_ADDR 0xff | 50 | #define PN_NO_ADDR 0xff |
50 | 51 | ||
diff --git a/include/net/protocol.h b/include/net/protocol.h index ffa5b8b1f1df..1089d5aabd49 100644 --- a/include/net/protocol.h +++ b/include/net/protocol.h | |||
@@ -53,7 +53,7 @@ struct inet6_protocol | |||
53 | 53 | ||
54 | void (*err_handler)(struct sk_buff *skb, | 54 | void (*err_handler)(struct sk_buff *skb, |
55 | struct inet6_skb_parm *opt, | 55 | struct inet6_skb_parm *opt, |
56 | int type, int code, int offset, | 56 | u8 type, u8 code, int offset, |
57 | __be32 info); | 57 | __be32 info); |
58 | 58 | ||
59 | int (*gso_send_check)(struct sk_buff *skb); | 59 | int (*gso_send_check)(struct sk_buff *skb); |
diff --git a/include/net/rawv6.h b/include/net/rawv6.h index 8a22599f26ba..f6b9b830df8c 100644 --- a/include/net/rawv6.h +++ b/include/net/rawv6.h | |||
@@ -6,7 +6,7 @@ | |||
6 | #include <net/protocol.h> | 6 | #include <net/protocol.h> |
7 | 7 | ||
8 | void raw6_icmp_error(struct sk_buff *, int nexthdr, | 8 | void raw6_icmp_error(struct sk_buff *, int nexthdr, |
9 | int type, int code, int inner_offset, __be32); | 9 | u8 type, u8 code, int inner_offset, __be32); |
10 | int raw6_local_deliver(struct sk_buff *, int); | 10 | int raw6_local_deliver(struct sk_buff *, int); |
11 | 11 | ||
12 | extern int rawv6_rcv(struct sock *sk, | 12 | extern int rawv6_rcv(struct sock *sk, |
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h index 9f80a7668289..d16a304cbed4 100644 --- a/include/net/sctp/sctp.h +++ b/include/net/sctp/sctp.h | |||
@@ -448,6 +448,7 @@ static inline void sctp_skb_set_owner_r(struct sk_buff *skb, struct sock *sk) | |||
448 | { | 448 | { |
449 | struct sctp_ulpevent *event = sctp_skb2event(skb); | 449 | struct sctp_ulpevent *event = sctp_skb2event(skb); |
450 | 450 | ||
451 | skb_orphan(skb); | ||
451 | skb->sk = sk; | 452 | skb->sk = sk; |
452 | skb->destructor = sctp_sock_rfree; | 453 | skb->destructor = sctp_sock_rfree; |
453 | atomic_add(event->rmem_len, &sk->sk_rmem_alloc); | 454 | atomic_add(event->rmem_len, &sk->sk_rmem_alloc); |
diff --git a/include/net/sock.h b/include/net/sock.h index 07133c5e9868..352f06bbd7a9 100644 --- a/include/net/sock.h +++ b/include/net/sock.h | |||
@@ -1252,6 +1252,7 @@ static inline int sk_has_allocations(const struct sock *sk) | |||
1252 | 1252 | ||
1253 | static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk) | 1253 | static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk) |
1254 | { | 1254 | { |
1255 | skb_orphan(skb); | ||
1255 | skb->sk = sk; | 1256 | skb->sk = sk; |
1256 | skb->destructor = sock_wfree; | 1257 | skb->destructor = sock_wfree; |
1257 | /* | 1258 | /* |
@@ -1264,6 +1265,7 @@ static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk) | |||
1264 | 1265 | ||
1265 | static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk) | 1266 | static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk) |
1266 | { | 1267 | { |
1268 | skb_orphan(skb); | ||
1267 | skb->sk = sk; | 1269 | skb->sk = sk; |
1268 | skb->destructor = sock_rfree; | 1270 | skb->destructor = sock_rfree; |
1269 | atomic_add(skb->truesize, &sk->sk_rmem_alloc); | 1271 | atomic_add(skb->truesize, &sk->sk_rmem_alloc); |
diff --git a/include/net/xfrm.h b/include/net/xfrm.h index 736bca450886..9e3a3f4c1f60 100644 --- a/include/net/xfrm.h +++ b/include/net/xfrm.h | |||
@@ -1274,7 +1274,7 @@ struct xfrm_tunnel { | |||
1274 | struct xfrm6_tunnel { | 1274 | struct xfrm6_tunnel { |
1275 | int (*handler)(struct sk_buff *skb); | 1275 | int (*handler)(struct sk_buff *skb); |
1276 | int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt, | 1276 | int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt, |
1277 | int type, int code, int offset, __be32 info); | 1277 | u8 type, u8 code, int offset, __be32 info); |
1278 | struct xfrm6_tunnel *next; | 1278 | struct xfrm6_tunnel *next; |
1279 | int priority; | 1279 | int priority; |
1280 | }; | 1280 | }; |
diff --git a/include/scsi/fc_encode.h b/include/scsi/fc_encode.h index 6300f556bce5..a0ff61c3e935 100644 --- a/include/scsi/fc_encode.h +++ b/include/scsi/fc_encode.h | |||
@@ -107,7 +107,6 @@ static inline int fc_ct_fill(struct fc_lport *lport, struct fc_frame *fp, | |||
107 | break; | 107 | break; |
108 | 108 | ||
109 | default: | 109 | default: |
110 | FC_DBG("Invalid op code %x \n", op); | ||
111 | return -EINVAL; | 110 | return -EINVAL; |
112 | } | 111 | } |
113 | *r_ctl = FC_RCTL_DD_UNSOL_CTL; | 112 | *r_ctl = FC_RCTL_DD_UNSOL_CTL; |
@@ -298,7 +297,6 @@ static inline int fc_els_fill(struct fc_lport *lport, struct fc_rport *rport, | |||
298 | break; | 297 | break; |
299 | 298 | ||
300 | default: | 299 | default: |
301 | FC_DBG("Invalid op code %x \n", op); | ||
302 | return -EINVAL; | 300 | return -EINVAL; |
303 | } | 301 | } |
304 | 302 | ||
diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h index ebdd9f4cf070..b92584a8843a 100644 --- a/include/scsi/libfc.h +++ b/include/scsi/libfc.h | |||
@@ -34,17 +34,72 @@ | |||
34 | 34 | ||
35 | #include <scsi/fc_frame.h> | 35 | #include <scsi/fc_frame.h> |
36 | 36 | ||
37 | #define LIBFC_DEBUG | 37 | #define FC_LIBFC_LOGGING 0x01 /* General logging, not categorized */ |
38 | 38 | #define FC_LPORT_LOGGING 0x02 /* lport layer logging */ | |
39 | #ifdef LIBFC_DEBUG | 39 | #define FC_DISC_LOGGING 0x04 /* discovery layer logging */ |
40 | /* Log messages */ | 40 | #define FC_RPORT_LOGGING 0x08 /* rport layer logging */ |
41 | #define FC_DBG(fmt, args...) \ | 41 | #define FC_FCP_LOGGING 0x10 /* I/O path logging */ |
42 | do { \ | 42 | #define FC_EM_LOGGING 0x20 /* Exchange Manager logging */ |
43 | printk(KERN_INFO "%s " fmt, __func__, ##args); \ | 43 | #define FC_EXCH_LOGGING 0x40 /* Exchange/Sequence logging */ |
44 | } while (0) | 44 | #define FC_SCSI_LOGGING 0x80 /* SCSI logging (mostly error handling) */ |
45 | #else | 45 | |
46 | #define FC_DBG(fmt, args...) | 46 | extern unsigned int fc_debug_logging; |
47 | #endif | 47 | |
48 | #define FC_CHECK_LOGGING(LEVEL, CMD) \ | ||
49 | do { \ | ||
50 | if (unlikely(fc_debug_logging & LEVEL)) \ | ||
51 | do { \ | ||
52 | CMD; \ | ||
53 | } while (0); \ | ||
54 | } while (0); | ||
55 | |||
56 | #define FC_LIBFC_DBG(fmt, args...) \ | ||
57 | FC_CHECK_LOGGING(FC_LIBFC_LOGGING, \ | ||
58 | printk(KERN_INFO "libfc: " fmt, ##args);) | ||
59 | |||
60 | #define FC_LPORT_DBG(lport, fmt, args...) \ | ||
61 | FC_CHECK_LOGGING(FC_LPORT_LOGGING, \ | ||
62 | printk(KERN_INFO "lport: %6x: " fmt, \ | ||
63 | fc_host_port_id(lport->host), ##args);) | ||
64 | |||
65 | #define FC_DISC_DBG(disc, fmt, args...) \ | ||
66 | FC_CHECK_LOGGING(FC_DISC_LOGGING, \ | ||
67 | printk(KERN_INFO "disc: %6x: " fmt, \ | ||
68 | fc_host_port_id(disc->lport->host), \ | ||
69 | ##args);) | ||
70 | |||
71 | #define FC_RPORT_DBG(rport, fmt, args...) \ | ||
72 | do { \ | ||
73 | struct fc_rport_libfc_priv *rdata = rport->dd_data; \ | ||
74 | struct fc_lport *lport = rdata->local_port; \ | ||
75 | FC_CHECK_LOGGING(FC_RPORT_LOGGING, \ | ||
76 | printk(KERN_INFO "rport: %6x: %6x: " fmt, \ | ||
77 | fc_host_port_id(lport->host), \ | ||
78 | rport->port_id, ##args);) \ | ||
79 | } while (0); | ||
80 | |||
81 | #define FC_FCP_DBG(pkt, fmt, args...) \ | ||
82 | FC_CHECK_LOGGING(FC_FCP_LOGGING, \ | ||
83 | printk(KERN_INFO "fcp: %6x: %6x: " fmt, \ | ||
84 | fc_host_port_id(pkt->lp->host), \ | ||
85 | pkt->rport->port_id, ##args);) | ||
86 | |||
87 | #define FC_EM_DBG(em, fmt, args...) \ | ||
88 | FC_CHECK_LOGGING(FC_EM_LOGGING, \ | ||
89 | printk(KERN_INFO "em: %6x: " fmt, \ | ||
90 | fc_host_port_id(em->lp->host), \ | ||
91 | ##args);) | ||
92 | |||
93 | #define FC_EXCH_DBG(exch, fmt, args...) \ | ||
94 | FC_CHECK_LOGGING(FC_EXCH_LOGGING, \ | ||
95 | printk(KERN_INFO "exch: %6x: %4x: " fmt, \ | ||
96 | fc_host_port_id(exch->lp->host), \ | ||
97 | exch->xid, ##args);) | ||
98 | |||
99 | #define FC_SCSI_DBG(lport, fmt, args...) \ | ||
100 | FC_CHECK_LOGGING(FC_SCSI_LOGGING, \ | ||
101 | printk(KERN_INFO "scsi: %6x: " fmt, \ | ||
102 | fc_host_port_id(lport->host), ##args);) | ||
48 | 103 | ||
49 | /* | 104 | /* |
50 | * libfc error codes | 105 | * libfc error codes |
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h index 196525cd402f..61afeb59a836 100644 --- a/include/scsi/libiscsi.h +++ b/include/scsi/libiscsi.h | |||
@@ -125,6 +125,10 @@ struct iscsi_task { | |||
125 | struct scsi_cmnd *sc; /* associated SCSI cmd*/ | 125 | struct scsi_cmnd *sc; /* associated SCSI cmd*/ |
126 | struct iscsi_conn *conn; /* used connection */ | 126 | struct iscsi_conn *conn; /* used connection */ |
127 | 127 | ||
128 | /* data processing tracking */ | ||
129 | unsigned long last_xfer; | ||
130 | unsigned long last_timeout; | ||
131 | bool have_checked_conn; | ||
128 | /* state set/tested under session->lock */ | 132 | /* state set/tested under session->lock */ |
129 | int state; | 133 | int state; |
130 | atomic_t refcount; | 134 | atomic_t refcount; |
diff --git a/include/scsi/scsi_driver.h b/include/scsi/scsi_driver.h index 1f5ca7f62116..9fd6702f02e2 100644 --- a/include/scsi/scsi_driver.h +++ b/include/scsi/scsi_driver.h | |||
@@ -32,5 +32,6 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req); | |||
32 | int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req); | 32 | int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req); |
33 | int scsi_prep_state_check(struct scsi_device *sdev, struct request *req); | 33 | int scsi_prep_state_check(struct scsi_device *sdev, struct request *req); |
34 | int scsi_prep_return(struct request_queue *q, struct request *req, int ret); | 34 | int scsi_prep_return(struct request_queue *q, struct request *req, int ret); |
35 | int scsi_prep_fn(struct request_queue *, struct request *); | ||
35 | 36 | ||
36 | #endif /* _SCSI_SCSI_DRIVER_H */ | 37 | #endif /* _SCSI_SCSI_DRIVER_H */ |