Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
+1721
-2049
+1
-1
Makefile
+1
-1
Makefile
+65
-20
arch/arm/configs/corgi_defconfig
+65
-20
arch/arm/configs/corgi_defconfig
···
1
1
#
2
2
# Automatically generated make config: don't edit
3
-
# Linux kernel version: 2.6.14-rc3
4
-
# Sun Oct 9 15:46:42 2005
3
+
# Linux kernel version: 2.6.15-rc2
4
+
# Mon Nov 28 10:30:09 2005
5
5
#
6
6
CONFIG_ARM=y
7
7
CONFIG_MMU=y
···
64
64
CONFIG_KMOD=y
65
65
66
66
#
67
+
# Block layer
68
+
#
69
+
70
+
#
71
+
# IO Schedulers
72
+
#
73
+
CONFIG_IOSCHED_NOOP=y
74
+
CONFIG_IOSCHED_AS=y
75
+
CONFIG_IOSCHED_DEADLINE=y
76
+
CONFIG_IOSCHED_CFQ=y
77
+
CONFIG_DEFAULT_AS=y
78
+
# CONFIG_DEFAULT_DEADLINE is not set
79
+
# CONFIG_DEFAULT_CFQ is not set
80
+
# CONFIG_DEFAULT_NOOP is not set
81
+
CONFIG_DEFAULT_IOSCHED="anticipatory"
82
+
83
+
#
67
84
# System Type
68
85
#
69
86
# CONFIG_ARCH_CLPS7500 is not set
···
102
85
# CONFIG_ARCH_LH7A40X is not set
103
86
# CONFIG_ARCH_OMAP is not set
104
87
# CONFIG_ARCH_VERSATILE is not set
88
+
# CONFIG_ARCH_REALVIEW is not set
105
89
# CONFIG_ARCH_IMX is not set
106
90
# CONFIG_ARCH_H720X is not set
107
91
# CONFIG_ARCH_AAEC2000 is not set
···
116
98
CONFIG_PXA_SHARPSL=y
117
99
CONFIG_PXA_SHARPSL_25x=y
118
100
# CONFIG_PXA_SHARPSL_27x is not set
119
-
# CONFIG_MACH_POODLE is not set
101
+
CONFIG_MACH_POODLE=y
120
102
CONFIG_MACH_CORGI=y
121
103
CONFIG_MACH_SHEPHERD=y
122
104
CONFIG_MACH_HUSKY=y
105
+
CONFIG_MACH_TOSA=y
123
106
CONFIG_PXA25x=y
124
107
CONFIG_PXA_SHARP_C7xx=y
108
+
CONFIG_PXA_SSP=y
125
109
126
110
#
127
111
# Processor Type
···
175
155
CONFIG_FLATMEM=y
176
156
CONFIG_FLAT_NODE_MEM_MAP=y
177
157
# CONFIG_SPARSEMEM_STATIC is not set
158
+
CONFIG_SPLIT_PTLOCK_CPUS=4096
178
159
CONFIG_ALIGNMENT_TRAP=y
179
160
180
161
#
···
256
235
CONFIG_IPV6_TUNNEL=m
257
236
CONFIG_NETFILTER=y
258
237
# CONFIG_NETFILTER_DEBUG is not set
238
+
239
+
#
240
+
# Core Netfilter Configuration
241
+
#
259
242
# CONFIG_NETFILTER_NETLINK is not set
260
243
261
244
#
···
381
356
# CONFIG_NET_DIVERT is not set
382
357
# CONFIG_ECONET is not set
383
358
# CONFIG_WAN_ROUTER is not set
359
+
360
+
#
361
+
# QoS and/or fair queueing
362
+
#
384
363
# CONFIG_NET_SCHED is not set
385
364
CONFIG_NET_CLS_ROUTE=y
386
365
···
442
413
# CONFIG_SMC_IRCC_FIR is not set
443
414
# CONFIG_ALI_FIR is not set
444
415
# CONFIG_VIA_FIR is not set
416
+
CONFIG_PXA_FICP=m
445
417
CONFIG_BT=m
446
418
CONFIG_BT_L2CAP=m
447
419
CONFIG_BT_SCO=m
···
461
431
CONFIG_BT_HCIUART=m
462
432
CONFIG_BT_HCIUART_H4=y
463
433
CONFIG_BT_HCIUART_BCSP=y
464
-
CONFIG_BT_HCIUART_BCSP_TXCRC=y
465
434
CONFIG_BT_HCIBCM203X=m
466
435
CONFIG_BT_HCIBPA10X=m
467
436
CONFIG_BT_HCIBFUSB=m
···
488
459
# CONFIG_DEBUG_DRIVER is not set
489
460
490
461
#
462
+
# Connector - unified userspace <-> kernelspace linker
463
+
#
464
+
# CONFIG_CONNECTOR is not set
465
+
466
+
#
491
467
# Memory Technology Devices (MTD)
492
468
#
493
469
CONFIG_MTD=y
···
511
477
# CONFIG_FTL is not set
512
478
# CONFIG_NFTL is not set
513
479
# CONFIG_INFTL is not set
480
+
# CONFIG_RFD_FTL is not set
514
481
515
482
#
516
483
# RAM/ROM/Flash chip drivers
···
567
532
# CONFIG_MTD_NAND_NANDSIM is not set
568
533
569
534
#
535
+
# OneNAND Flash Device Drivers
536
+
#
537
+
# CONFIG_MTD_ONENAND is not set
538
+
539
+
#
570
540
# Parallel port support
571
541
#
572
542
# CONFIG_PARPORT is not set
···
591
551
# CONFIG_BLK_DEV_RAM is not set
592
552
CONFIG_BLK_DEV_RAM_COUNT=16
593
553
# CONFIG_CDROM_PKTCDVD is not set
594
-
595
-
#
596
-
# IO Schedulers
597
-
#
598
-
CONFIG_IOSCHED_NOOP=y
599
-
CONFIG_IOSCHED_AS=y
600
-
CONFIG_IOSCHED_DEADLINE=y
601
-
CONFIG_IOSCHED_CFQ=y
602
554
# CONFIG_ATA_OVER_ETH is not set
603
555
604
556
#
···
657
625
#
658
626
# SCSI low-level drivers
659
627
#
628
+
# CONFIG_ISCSI_TCP is not set
660
629
# CONFIG_SCSI_SATA is not set
661
630
# CONFIG_SCSI_DEBUG is not set
662
631
···
781
748
# CONFIG_PPP_SYNC_TTY is not set
782
749
# CONFIG_PPP_DEFLATE is not set
783
750
CONFIG_PPP_BSDCOMP=m
751
+
# CONFIG_PPP_MPPE is not set
784
752
# CONFIG_PPPOE is not set
785
753
# CONFIG_SLIP is not set
786
754
# CONFIG_SHAPER is not set
···
884
850
# PCMCIA character devices
885
851
#
886
852
# CONFIG_SYNCLINK_CS is not set
853
+
# CONFIG_CARDMAN_4000 is not set
854
+
# CONFIG_CARDMAN_4040 is not set
887
855
# CONFIG_RAW_DRIVER is not set
888
856
889
857
#
890
858
# TPM devices
891
859
#
860
+
# CONFIG_TCG_TPM is not set
861
+
# CONFIG_TELCLOCK is not set
892
862
893
863
#
894
864
# I2C support
···
927
889
# CONFIG_SENSORS_PCF8591 is not set
928
890
# CONFIG_SENSORS_RTC8564 is not set
929
891
# CONFIG_SENSORS_MAX6875 is not set
892
+
# CONFIG_RTC_X1205_I2C is not set
930
893
# CONFIG_I2C_DEBUG_CORE is not set
931
894
# CONFIG_I2C_DEBUG_ALGO is not set
932
895
# CONFIG_I2C_DEBUG_BUS is not set
···
996
957
# CONFIG_VIDEO_SAA5246A is not set
997
958
# CONFIG_VIDEO_SAA5249 is not set
998
959
# CONFIG_TUNER_3036 is not set
960
+
# CONFIG_VIDEO_EM28XX is not set
999
961
# CONFIG_VIDEO_OVCAMCHIP is not set
962
+
# CONFIG_VIDEO_AUDIO_DECODER is not set
963
+
# CONFIG_VIDEO_DECODER is not set
1000
964
1001
965
#
1002
966
# Radio Adapters
···
1018
976
CONFIG_FB_CFB_FILLRECT=y
1019
977
CONFIG_FB_CFB_COPYAREA=y
1020
978
CONFIG_FB_CFB_IMAGEBLIT=y
1021
-
CONFIG_FB_SOFT_CURSOR=y
1022
979
# CONFIG_FB_MACMODES is not set
1023
980
# CONFIG_FB_MODE_HELPERS is not set
1024
981
# CONFIG_FB_TILEBLITTING is not set
982
+
# CONFIG_FB_S1D13XXX is not set
1025
983
# CONFIG_FB_PXA is not set
1026
984
CONFIG_FB_W100=y
1027
-
# CONFIG_FB_S1D13XXX is not set
1028
985
# CONFIG_FB_VIRTUAL is not set
1029
986
1030
987
#
···
1032
991
# CONFIG_VGA_CONSOLE is not set
1033
992
CONFIG_DUMMY_CONSOLE=y
1034
993
CONFIG_FRAMEBUFFER_CONSOLE=y
994
+
# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
1035
995
CONFIG_FONTS=y
1036
996
CONFIG_FONT_8x8=y
1037
997
CONFIG_FONT_8x16=y
···
1129
1087
# USB Device Class drivers
1130
1088
#
1131
1089
# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
1132
-
1133
-
#
1134
-
# USB Bluetooth TTY can only be used with disabled Bluetooth subsystem
1135
-
#
1136
1090
CONFIG_USB_ACM=m
1137
1091
CONFIG_USB_PRINTER=m
1138
1092
1139
1093
#
1140
-
# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
1094
+
# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
1095
+
#
1096
+
1097
+
#
1098
+
# may also be needed; see USB_STORAGE Help for more information
1141
1099
#
1142
1100
CONFIG_USB_STORAGE=m
1143
1101
# CONFIG_USB_STORAGE_DEBUG is not set
···
1149
1107
# CONFIG_USB_STORAGE_SDDR09 is not set
1150
1108
# CONFIG_USB_STORAGE_SDDR55 is not set
1151
1109
# CONFIG_USB_STORAGE_JUMPSHOT is not set
1152
-
# CONFIG_USB_STORAGE_ONETOUCH is not set
1153
1110
1154
1111
#
1155
1112
# USB Input Devices
···
1226
1185
CONFIG_USB_SERIAL=m
1227
1186
CONFIG_USB_SERIAL_GENERIC=y
1228
1187
# CONFIG_USB_SERIAL_AIRPRIME is not set
1188
+
# CONFIG_USB_SERIAL_ANYDATA is not set
1229
1189
CONFIG_USB_SERIAL_BELKIN=m
1230
1190
# CONFIG_USB_SERIAL_WHITEHEAT is not set
1231
1191
CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m
···
1382
1340
CONFIG_JFFS2_FS=y
1383
1341
CONFIG_JFFS2_FS_DEBUG=0
1384
1342
CONFIG_JFFS2_FS_WRITEBUFFER=y
1343
+
CONFIG_JFFS2_SUMMARY=y
1385
1344
CONFIG_JFFS2_COMPRESSION_OPTIONS=y
1386
1345
CONFIG_JFFS2_ZLIB=y
1387
1346
CONFIG_JFFS2_RTIME=y
···
1509
1466
CONFIG_DEBUG_BUGVERBOSE=y
1510
1467
# CONFIG_DEBUG_INFO is not set
1511
1468
# CONFIG_DEBUG_FS is not set
1469
+
# CONFIG_DEBUG_VM is not set
1512
1470
CONFIG_FRAME_POINTER=y
1471
+
# CONFIG_RCU_TORTURE_TEST is not set
1513
1472
# CONFIG_DEBUG_USER is not set
1514
1473
# CONFIG_DEBUG_WAITQ is not set
1515
1474
CONFIG_DEBUG_ERRORS=y
-1015
arch/arm/configs/poodle_defconfig
-1015
arch/arm/configs/poodle_defconfig
···
1
-
#
2
-
# Automatically generated make config: don't edit
3
-
# Linux kernel version: 2.6.14-rc3
4
-
# Sun Oct 9 17:04:29 2005
5
-
#
6
-
CONFIG_ARM=y
7
-
CONFIG_MMU=y
8
-
CONFIG_UID16=y
9
-
CONFIG_RWSEM_GENERIC_SPINLOCK=y
10
-
CONFIG_GENERIC_CALIBRATE_DELAY=y
11
-
12
-
#
13
-
# Code maturity level options
14
-
#
15
-
CONFIG_EXPERIMENTAL=y
16
-
CONFIG_CLEAN_COMPILE=y
17
-
CONFIG_BROKEN_ON_SMP=y
18
-
CONFIG_LOCK_KERNEL=y
19
-
CONFIG_INIT_ENV_ARG_LIMIT=32
20
-
21
-
#
22
-
# General setup
23
-
#
24
-
CONFIG_LOCALVERSION=""
25
-
CONFIG_LOCALVERSION_AUTO=y
26
-
CONFIG_SWAP=y
27
-
CONFIG_SYSVIPC=y
28
-
# CONFIG_POSIX_MQUEUE is not set
29
-
CONFIG_BSD_PROCESS_ACCT=y
30
-
# CONFIG_BSD_PROCESS_ACCT_V3 is not set
31
-
CONFIG_SYSCTL=y
32
-
# CONFIG_AUDIT is not set
33
-
CONFIG_HOTPLUG=y
34
-
CONFIG_KOBJECT_UEVENT=y
35
-
# CONFIG_IKCONFIG is not set
36
-
CONFIG_INITRAMFS_SOURCE=""
37
-
CONFIG_EMBEDDED=y
38
-
CONFIG_KALLSYMS=y
39
-
# CONFIG_KALLSYMS_ALL is not set
40
-
# CONFIG_KALLSYMS_EXTRA_PASS is not set
41
-
CONFIG_PRINTK=y
42
-
CONFIG_BUG=y
43
-
CONFIG_BASE_FULL=y
44
-
CONFIG_FUTEX=y
45
-
CONFIG_EPOLL=y
46
-
# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
47
-
CONFIG_SHMEM=y
48
-
CONFIG_CC_ALIGN_FUNCTIONS=0
49
-
CONFIG_CC_ALIGN_LABELS=0
50
-
CONFIG_CC_ALIGN_LOOPS=0
51
-
CONFIG_CC_ALIGN_JUMPS=0
52
-
# CONFIG_TINY_SHMEM is not set
53
-
CONFIG_BASE_SMALL=0
54
-
55
-
#
56
-
# Loadable module support
57
-
#
58
-
CONFIG_MODULES=y
59
-
CONFIG_MODULE_UNLOAD=y
60
-
CONFIG_MODULE_FORCE_UNLOAD=y
61
-
CONFIG_OBSOLETE_MODPARM=y
62
-
CONFIG_MODVERSIONS=y
63
-
# CONFIG_MODULE_SRCVERSION_ALL is not set
64
-
CONFIG_KMOD=y
65
-
66
-
#
67
-
# System Type
68
-
#
69
-
# CONFIG_ARCH_CLPS7500 is not set
70
-
# CONFIG_ARCH_CLPS711X is not set
71
-
# CONFIG_ARCH_CO285 is not set
72
-
# CONFIG_ARCH_EBSA110 is not set
73
-
# CONFIG_ARCH_CAMELOT is not set
74
-
# CONFIG_ARCH_FOOTBRIDGE is not set
75
-
# CONFIG_ARCH_INTEGRATOR is not set
76
-
# CONFIG_ARCH_IOP3XX is not set
77
-
# CONFIG_ARCH_IXP4XX is not set
78
-
# CONFIG_ARCH_IXP2000 is not set
79
-
# CONFIG_ARCH_L7200 is not set
80
-
CONFIG_ARCH_PXA=y
81
-
# CONFIG_ARCH_RPC is not set
82
-
# CONFIG_ARCH_SA1100 is not set
83
-
# CONFIG_ARCH_S3C2410 is not set
84
-
# CONFIG_ARCH_SHARK is not set
85
-
# CONFIG_ARCH_LH7A40X is not set
86
-
# CONFIG_ARCH_OMAP is not set
87
-
# CONFIG_ARCH_VERSATILE is not set
88
-
# CONFIG_ARCH_IMX is not set
89
-
# CONFIG_ARCH_H720X is not set
90
-
# CONFIG_ARCH_AAEC2000 is not set
91
-
92
-
#
93
-
# Intel PXA2xx Implementations
94
-
#
95
-
# CONFIG_ARCH_LUBBOCK is not set
96
-
# CONFIG_MACH_MAINSTONE is not set
97
-
# CONFIG_ARCH_PXA_IDP is not set
98
-
CONFIG_PXA_SHARPSL=y
99
-
CONFIG_PXA_SHARPSL_25x=y
100
-
# CONFIG_PXA_SHARPSL_27x is not set
101
-
CONFIG_MACH_POODLE=y
102
-
# CONFIG_MACH_CORGI is not set
103
-
# CONFIG_MACH_SHEPHERD is not set
104
-
# CONFIG_MACH_HUSKY is not set
105
-
CONFIG_PXA25x=y
106
-
107
-
#
108
-
# Processor Type
109
-
#
110
-
CONFIG_CPU_32=y
111
-
CONFIG_CPU_XSCALE=y
112
-
CONFIG_CPU_32v5=y
113
-
CONFIG_CPU_ABRT_EV5T=y
114
-
CONFIG_CPU_CACHE_VIVT=y
115
-
CONFIG_CPU_TLB_V4WBI=y
116
-
117
-
#
118
-
# Processor Features
119
-
#
120
-
CONFIG_ARM_THUMB=y
121
-
CONFIG_XSCALE_PMU=y
122
-
CONFIG_SHARP_LOCOMO=y
123
-
CONFIG_SHARP_PARAM=y
124
-
CONFIG_SHARP_SCOOP=y
125
-
126
-
#
127
-
# Bus support
128
-
#
129
-
CONFIG_ISA_DMA_API=y
130
-
131
-
#
132
-
# PCCARD (PCMCIA/CardBus) support
133
-
#
134
-
CONFIG_PCCARD=y
135
-
# CONFIG_PCMCIA_DEBUG is not set
136
-
CONFIG_PCMCIA=y
137
-
CONFIG_PCMCIA_LOAD_CIS=y
138
-
CONFIG_PCMCIA_IOCTL=y
139
-
140
-
#
141
-
# PC-card bridges
142
-
#
143
-
CONFIG_PCMCIA_PXA2XX=y
144
-
145
-
#
146
-
# Kernel Features
147
-
#
148
-
CONFIG_PREEMPT=y
149
-
# CONFIG_NO_IDLE_HZ is not set
150
-
# CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
151
-
CONFIG_SELECT_MEMORY_MODEL=y
152
-
CONFIG_FLATMEM_MANUAL=y
153
-
# CONFIG_DISCONTIGMEM_MANUAL is not set
154
-
# CONFIG_SPARSEMEM_MANUAL is not set
155
-
CONFIG_FLATMEM=y
156
-
CONFIG_FLAT_NODE_MEM_MAP=y
157
-
# CONFIG_SPARSEMEM_STATIC is not set
158
-
CONFIG_ALIGNMENT_TRAP=y
159
-
160
-
#
161
-
# Boot options
162
-
#
163
-
CONFIG_ZBOOT_ROM_TEXT=0x0
164
-
CONFIG_ZBOOT_ROM_BSS=0x0
165
-
CONFIG_CMDLINE="console=ttyS0,115200n8 console=tty1 noinitrd root=/dev/mtdblock2 rootfstype=jffs2 debug"
166
-
# CONFIG_XIP_KERNEL is not set
167
-
168
-
#
169
-
# Floating point emulation
170
-
#
171
-
172
-
#
173
-
# At least one emulation must be selected
174
-
#
175
-
CONFIG_FPE_NWFPE=y
176
-
# CONFIG_FPE_NWFPE_XP is not set
177
-
# CONFIG_FPE_FASTFPE is not set
178
-
179
-
#
180
-
# Userspace binary formats
181
-
#
182
-
CONFIG_BINFMT_ELF=y
183
-
CONFIG_BINFMT_AOUT=m
184
-
CONFIG_BINFMT_MISC=m
185
-
# CONFIG_ARTHUR is not set
186
-
187
-
#
188
-
# Power management options
189
-
#
190
-
CONFIG_PM=y
191
-
CONFIG_APM=y
192
-
193
-
#
194
-
# Networking
195
-
#
196
-
CONFIG_NET=y
197
-
198
-
#
199
-
# Networking options
200
-
#
201
-
CONFIG_PACKET=y
202
-
CONFIG_PACKET_MMAP=y
203
-
CONFIG_UNIX=y
204
-
# CONFIG_NET_KEY is not set
205
-
CONFIG_INET=y
206
-
# CONFIG_IP_MULTICAST is not set
207
-
# CONFIG_IP_ADVANCED_ROUTER is not set
208
-
CONFIG_IP_FIB_HASH=y
209
-
# CONFIG_IP_PNP is not set
210
-
# CONFIG_NET_IPIP is not set
211
-
# CONFIG_NET_IPGRE is not set
212
-
# CONFIG_ARPD is not set
213
-
CONFIG_SYN_COOKIES=y
214
-
# CONFIG_INET_AH is not set
215
-
# CONFIG_INET_ESP is not set
216
-
# CONFIG_INET_IPCOMP is not set
217
-
# CONFIG_INET_TUNNEL is not set
218
-
CONFIG_INET_DIAG=y
219
-
CONFIG_INET_TCP_DIAG=y
220
-
# CONFIG_TCP_CONG_ADVANCED is not set
221
-
CONFIG_TCP_CONG_BIC=y
222
-
# CONFIG_IPV6 is not set
223
-
# CONFIG_NETFILTER is not set
224
-
225
-
#
226
-
# DCCP Configuration (EXPERIMENTAL)
227
-
#
228
-
# CONFIG_IP_DCCP is not set
229
-
230
-
#
231
-
# SCTP Configuration (EXPERIMENTAL)
232
-
#
233
-
# CONFIG_IP_SCTP is not set
234
-
# CONFIG_ATM is not set
235
-
# CONFIG_BRIDGE is not set
236
-
# CONFIG_VLAN_8021Q is not set
237
-
# CONFIG_DECNET is not set
238
-
# CONFIG_LLC2 is not set
239
-
# CONFIG_IPX is not set
240
-
# CONFIG_ATALK is not set
241
-
# CONFIG_X25 is not set
242
-
# CONFIG_LAPB is not set
243
-
# CONFIG_NET_DIVERT is not set
244
-
# CONFIG_ECONET is not set
245
-
# CONFIG_WAN_ROUTER is not set
246
-
# CONFIG_NET_SCHED is not set
247
-
# CONFIG_NET_CLS_ROUTE is not set
248
-
249
-
#
250
-
# Network testing
251
-
#
252
-
# CONFIG_NET_PKTGEN is not set
253
-
# CONFIG_HAMRADIO is not set
254
-
# CONFIG_IRDA is not set
255
-
# CONFIG_BT is not set
256
-
# CONFIG_IEEE80211 is not set
257
-
258
-
#
259
-
# Device Drivers
260
-
#
261
-
262
-
#
263
-
# Generic Driver Options
264
-
#
265
-
CONFIG_STANDALONE=y
266
-
CONFIG_PREVENT_FIRMWARE_BUILD=y
267
-
CONFIG_FW_LOADER=y
268
-
# CONFIG_DEBUG_DRIVER is not set
269
-
270
-
#
271
-
# Memory Technology Devices (MTD)
272
-
#
273
-
CONFIG_MTD=y
274
-
# CONFIG_MTD_DEBUG is not set
275
-
# CONFIG_MTD_CONCAT is not set
276
-
CONFIG_MTD_PARTITIONS=y
277
-
# CONFIG_MTD_REDBOOT_PARTS is not set
278
-
# CONFIG_MTD_CMDLINE_PARTS is not set
279
-
# CONFIG_MTD_AFS_PARTS is not set
280
-
281
-
#
282
-
# User Modules And Translation Layers
283
-
#
284
-
CONFIG_MTD_CHAR=y
285
-
CONFIG_MTD_BLOCK=y
286
-
# CONFIG_FTL is not set
287
-
# CONFIG_NFTL is not set
288
-
# CONFIG_INFTL is not set
289
-
290
-
#
291
-
# RAM/ROM/Flash chip drivers
292
-
#
293
-
# CONFIG_MTD_CFI is not set
294
-
# CONFIG_MTD_JEDECPROBE is not set
295
-
CONFIG_MTD_MAP_BANK_WIDTH_1=y
296
-
CONFIG_MTD_MAP_BANK_WIDTH_2=y
297
-
CONFIG_MTD_MAP_BANK_WIDTH_4=y
298
-
# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
299
-
# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
300
-
# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
301
-
CONFIG_MTD_CFI_I1=y
302
-
CONFIG_MTD_CFI_I2=y
303
-
# CONFIG_MTD_CFI_I4 is not set
304
-
# CONFIG_MTD_CFI_I8 is not set
305
-
# CONFIG_MTD_RAM is not set
306
-
# CONFIG_MTD_ROM is not set
307
-
# CONFIG_MTD_ABSENT is not set
308
-
309
-
#
310
-
# Mapping drivers for chip access
311
-
#
312
-
CONFIG_MTD_COMPLEX_MAPPINGS=y
313
-
CONFIG_MTD_SHARP_SL=y
314
-
# CONFIG_MTD_PLATRAM is not set
315
-
316
-
#
317
-
# Self-contained MTD device drivers
318
-
#
319
-
# CONFIG_MTD_SLRAM is not set
320
-
# CONFIG_MTD_PHRAM is not set
321
-
# CONFIG_MTD_MTDRAM is not set
322
-
# CONFIG_MTD_BLKMTD is not set
323
-
# CONFIG_MTD_BLOCK2MTD is not set
324
-
325
-
#
326
-
# Disk-On-Chip Device Drivers
327
-
#
328
-
# CONFIG_MTD_DOC2000 is not set
329
-
# CONFIG_MTD_DOC2001 is not set
330
-
# CONFIG_MTD_DOC2001PLUS is not set
331
-
332
-
#
333
-
# NAND Flash Device Drivers
334
-
#
335
-
CONFIG_MTD_NAND=y
336
-
CONFIG_MTD_NAND_VERIFY_WRITE=y
337
-
# CONFIG_MTD_NAND_H1900 is not set
338
-
CONFIG_MTD_NAND_IDS=y
339
-
# CONFIG_MTD_NAND_DISKONCHIP is not set
340
-
CONFIG_MTD_NAND_SHARPSL=y
341
-
# CONFIG_MTD_NAND_NANDSIM is not set
342
-
343
-
#
344
-
# Parallel port support
345
-
#
346
-
# CONFIG_PARPORT is not set
347
-
348
-
#
349
-
# Plug and Play support
350
-
#
351
-
352
-
#
353
-
# Block devices
354
-
#
355
-
# CONFIG_BLK_DEV_COW_COMMON is not set
356
-
CONFIG_BLK_DEV_LOOP=y
357
-
# CONFIG_BLK_DEV_CRYPTOLOOP is not set
358
-
# CONFIG_BLK_DEV_NBD is not set
359
-
# CONFIG_BLK_DEV_RAM is not set
360
-
CONFIG_BLK_DEV_RAM_COUNT=16
361
-
# CONFIG_CDROM_PKTCDVD is not set
362
-
363
-
#
364
-
# IO Schedulers
365
-
#
366
-
CONFIG_IOSCHED_NOOP=y
367
-
CONFIG_IOSCHED_AS=y
368
-
CONFIG_IOSCHED_DEADLINE=y
369
-
CONFIG_IOSCHED_CFQ=y
370
-
# CONFIG_ATA_OVER_ETH is not set
371
-
372
-
#
373
-
# ATA/ATAPI/MFM/RLL support
374
-
#
375
-
CONFIG_IDE=y
376
-
CONFIG_BLK_DEV_IDE=y
377
-
378
-
#
379
-
# Please see Documentation/ide.txt for help/info on IDE drives
380
-
#
381
-
# CONFIG_BLK_DEV_IDE_SATA is not set
382
-
CONFIG_BLK_DEV_IDEDISK=y
383
-
# CONFIG_IDEDISK_MULTI_MODE is not set
384
-
CONFIG_BLK_DEV_IDECS=y
385
-
# CONFIG_BLK_DEV_IDECD is not set
386
-
# CONFIG_BLK_DEV_IDETAPE is not set
387
-
# CONFIG_BLK_DEV_IDEFLOPPY is not set
388
-
# CONFIG_IDE_TASK_IOCTL is not set
389
-
390
-
#
391
-
# IDE chipset support/bugfixes
392
-
#
393
-
CONFIG_IDE_GENERIC=y
394
-
# CONFIG_IDE_ARM is not set
395
-
# CONFIG_BLK_DEV_IDEDMA is not set
396
-
# CONFIG_IDEDMA_AUTO is not set
397
-
# CONFIG_BLK_DEV_HD is not set
398
-
399
-
#
400
-
# SCSI device support
401
-
#
402
-
# CONFIG_RAID_ATTRS is not set
403
-
# CONFIG_SCSI is not set
404
-
405
-
#
406
-
# Multi-device support (RAID and LVM)
407
-
#
408
-
# CONFIG_MD is not set
409
-
410
-
#
411
-
# Fusion MPT device support
412
-
#
413
-
# CONFIG_FUSION is not set
414
-
415
-
#
416
-
# IEEE 1394 (FireWire) support
417
-
#
418
-
419
-
#
420
-
# I2O device support
421
-
#
422
-
423
-
#
424
-
# Network device support
425
-
#
426
-
CONFIG_NETDEVICES=y
427
-
# CONFIG_DUMMY is not set
428
-
# CONFIG_BONDING is not set
429
-
# CONFIG_EQUALIZER is not set
430
-
# CONFIG_TUN is not set
431
-
432
-
#
433
-
# PHY device support
434
-
#
435
-
# CONFIG_PHYLIB is not set
436
-
437
-
#
438
-
# Ethernet (10 or 100Mbit)
439
-
#
440
-
CONFIG_NET_ETHERNET=y
441
-
# CONFIG_MII is not set
442
-
# CONFIG_SMC91X is not set
443
-
# CONFIG_DM9000 is not set
444
-
445
-
#
446
-
# Ethernet (1000 Mbit)
447
-
#
448
-
449
-
#
450
-
# Ethernet (10000 Mbit)
451
-
#
452
-
453
-
#
454
-
# Token Ring devices
455
-
#
456
-
457
-
#
458
-
# Wireless LAN (non-hamradio)
459
-
#
460
-
CONFIG_NET_RADIO=y
461
-
462
-
#
463
-
# Obsolete Wireless cards support (pre-802.11)
464
-
#
465
-
# CONFIG_STRIP is not set
466
-
# CONFIG_PCMCIA_WAVELAN is not set
467
-
# CONFIG_PCMCIA_NETWAVE is not set
468
-
469
-
#
470
-
# Wireless 802.11 Frequency Hopping cards support
471
-
#
472
-
# CONFIG_PCMCIA_RAYCS is not set
473
-
474
-
#
475
-
# Wireless 802.11b ISA/PCI cards support
476
-
#
477
-
# CONFIG_HERMES is not set
478
-
# CONFIG_ATMEL is not set
479
-
480
-
#
481
-
# Wireless 802.11b Pcmcia/Cardbus cards support
482
-
#
483
-
# CONFIG_AIRO_CS is not set
484
-
# CONFIG_PCMCIA_WL3501 is not set
485
-
# CONFIG_HOSTAP is not set
486
-
CONFIG_NET_WIRELESS=y
487
-
488
-
#
489
-
# PCMCIA network device support
490
-
#
491
-
CONFIG_NET_PCMCIA=y
492
-
# CONFIG_PCMCIA_3C589 is not set
493
-
# CONFIG_PCMCIA_3C574 is not set
494
-
# CONFIG_PCMCIA_FMVJ18X is not set
495
-
CONFIG_PCMCIA_PCNET=y
496
-
# CONFIG_PCMCIA_NMCLAN is not set
497
-
# CONFIG_PCMCIA_SMC91C92 is not set
498
-
# CONFIG_PCMCIA_XIRC2PS is not set
499
-
# CONFIG_PCMCIA_AXNET is not set
500
-
501
-
#
502
-
# Wan interfaces
503
-
#
504
-
# CONFIG_WAN is not set
505
-
CONFIG_PPP=m
506
-
# CONFIG_PPP_MULTILINK is not set
507
-
# CONFIG_PPP_FILTER is not set
508
-
CONFIG_PPP_ASYNC=m
509
-
# CONFIG_PPP_SYNC_TTY is not set
510
-
# CONFIG_PPP_DEFLATE is not set
511
-
CONFIG_PPP_BSDCOMP=m
512
-
# CONFIG_PPPOE is not set
513
-
# CONFIG_SLIP is not set
514
-
# CONFIG_SHAPER is not set
515
-
# CONFIG_NETCONSOLE is not set
516
-
# CONFIG_NETPOLL is not set
517
-
# CONFIG_NET_POLL_CONTROLLER is not set
518
-
519
-
#
520
-
# ISDN subsystem
521
-
#
522
-
# CONFIG_ISDN is not set
523
-
524
-
#
525
-
# Input device support
526
-
#
527
-
CONFIG_INPUT=y
528
-
529
-
#
530
-
# Userland interfaces
531
-
#
532
-
# CONFIG_INPUT_MOUSEDEV is not set
533
-
# CONFIG_INPUT_JOYDEV is not set
534
-
CONFIG_INPUT_TSDEV=y
535
-
CONFIG_INPUT_TSDEV_SCREEN_X=240
536
-
CONFIG_INPUT_TSDEV_SCREEN_Y=320
537
-
CONFIG_INPUT_EVDEV=y
538
-
CONFIG_INPUT_EVBUG=y
539
-
540
-
#
541
-
# Input Device Drivers
542
-
#
543
-
CONFIG_INPUT_KEYBOARD=y
544
-
# CONFIG_KEYBOARD_ATKBD is not set
545
-
# CONFIG_KEYBOARD_SUNKBD is not set
546
-
# CONFIG_KEYBOARD_LKKBD is not set
547
-
CONFIG_KEYBOARD_LOCOMO=y
548
-
# CONFIG_KEYBOARD_XTKBD is not set
549
-
# CONFIG_KEYBOARD_NEWTON is not set
550
-
# CONFIG_KEYBOARD_CORGI is not set
551
-
CONFIG_KEYBOARD_SPITZ=y
552
-
# CONFIG_INPUT_MOUSE is not set
553
-
# CONFIG_INPUT_JOYSTICK is not set
554
-
# CONFIG_INPUT_TOUCHSCREEN is not set
555
-
# CONFIG_INPUT_MISC is not set
556
-
557
-
#
558
-
# Hardware I/O ports
559
-
#
560
-
# CONFIG_SERIO is not set
561
-
# CONFIG_GAMEPORT is not set
562
-
563
-
#
564
-
# Character devices
565
-
#
566
-
CONFIG_VT=y
567
-
CONFIG_VT_CONSOLE=y
568
-
CONFIG_HW_CONSOLE=y
569
-
# CONFIG_SERIAL_NONSTANDARD is not set
570
-
571
-
#
572
-
# Serial drivers
573
-
#
574
-
# CONFIG_SERIAL_8250 is not set
575
-
576
-
#
577
-
# Non-8250 serial port support
578
-
#
579
-
CONFIG_SERIAL_PXA=y
580
-
CONFIG_SERIAL_PXA_CONSOLE=y
581
-
CONFIG_SERIAL_CORE=y
582
-
CONFIG_SERIAL_CORE_CONSOLE=y
583
-
CONFIG_UNIX98_PTYS=y
584
-
# CONFIG_LEGACY_PTYS is not set
585
-
586
-
#
587
-
# IPMI
588
-
#
589
-
# CONFIG_IPMI_HANDLER is not set
590
-
591
-
#
592
-
# Watchdog Cards
593
-
#
594
-
# CONFIG_WATCHDOG is not set
595
-
# CONFIG_NVRAM is not set
596
-
# CONFIG_RTC is not set
597
-
# CONFIG_DTLK is not set
598
-
# CONFIG_R3964 is not set
599
-
600
-
#
601
-
# Ftape, the floppy tape device driver
602
-
#
603
-
604
-
#
605
-
# PCMCIA character devices
606
-
#
607
-
# CONFIG_SYNCLINK_CS is not set
608
-
# CONFIG_RAW_DRIVER is not set
609
-
610
-
#
611
-
# TPM devices
612
-
#
613
-
614
-
#
615
-
# I2C support
616
-
#
617
-
CONFIG_I2C=y
618
-
# CONFIG_I2C_CHARDEV is not set
619
-
620
-
#
621
-
# I2C Algorithms
622
-
#
623
-
CONFIG_I2C_ALGOBIT=y
624
-
# CONFIG_I2C_ALGOPCF is not set
625
-
# CONFIG_I2C_ALGOPCA is not set
626
-
627
-
#
628
-
# I2C Hardware Bus support
629
-
#
630
-
# CONFIG_I2C_PXA is not set
631
-
# CONFIG_I2C_PARPORT_LIGHT is not set
632
-
# CONFIG_I2C_STUB is not set
633
-
# CONFIG_I2C_PCA_ISA is not set
634
-
635
-
#
636
-
# Miscellaneous I2C Chip support
637
-
#
638
-
# CONFIG_SENSORS_DS1337 is not set
639
-
# CONFIG_SENSORS_DS1374 is not set
640
-
# CONFIG_SENSORS_EEPROM is not set
641
-
# CONFIG_SENSORS_PCF8574 is not set
642
-
# CONFIG_SENSORS_PCA9539 is not set
643
-
# CONFIG_SENSORS_PCF8591 is not set
644
-
# CONFIG_SENSORS_RTC8564 is not set
645
-
# CONFIG_SENSORS_MAX6875 is not set
646
-
CONFIG_I2C_DEBUG_CORE=y
647
-
CONFIG_I2C_DEBUG_ALGO=y
648
-
CONFIG_I2C_DEBUG_BUS=y
649
-
# CONFIG_I2C_DEBUG_CHIP is not set
650
-
651
-
#
652
-
# Hardware Monitoring support
653
-
#
654
-
CONFIG_HWMON=y
655
-
# CONFIG_HWMON_VID is not set
656
-
# CONFIG_SENSORS_ADM1021 is not set
657
-
# CONFIG_SENSORS_ADM1025 is not set
658
-
# CONFIG_SENSORS_ADM1026 is not set
659
-
# CONFIG_SENSORS_ADM1031 is not set
660
-
# CONFIG_SENSORS_ADM9240 is not set
661
-
# CONFIG_SENSORS_ASB100 is not set
662
-
# CONFIG_SENSORS_ATXP1 is not set
663
-
# CONFIG_SENSORS_DS1621 is not set
664
-
# CONFIG_SENSORS_FSCHER is not set
665
-
# CONFIG_SENSORS_FSCPOS is not set
666
-
# CONFIG_SENSORS_GL518SM is not set
667
-
# CONFIG_SENSORS_GL520SM is not set
668
-
# CONFIG_SENSORS_IT87 is not set
669
-
# CONFIG_SENSORS_LM63 is not set
670
-
# CONFIG_SENSORS_LM75 is not set
671
-
# CONFIG_SENSORS_LM77 is not set
672
-
# CONFIG_SENSORS_LM78 is not set
673
-
# CONFIG_SENSORS_LM80 is not set
674
-
# CONFIG_SENSORS_LM83 is not set
675
-
# CONFIG_SENSORS_LM85 is not set
676
-
# CONFIG_SENSORS_LM87 is not set
677
-
# CONFIG_SENSORS_LM90 is not set
678
-
# CONFIG_SENSORS_LM92 is not set
679
-
# CONFIG_SENSORS_MAX1619 is not set
680
-
# CONFIG_SENSORS_PC87360 is not set
681
-
# CONFIG_SENSORS_SMSC47M1 is not set
682
-
# CONFIG_SENSORS_SMSC47B397 is not set
683
-
# CONFIG_SENSORS_W83781D is not set
684
-
# CONFIG_SENSORS_W83792D is not set
685
-
# CONFIG_SENSORS_W83L785TS is not set
686
-
# CONFIG_SENSORS_W83627HF is not set
687
-
# CONFIG_SENSORS_W83627EHF is not set
688
-
# CONFIG_HWMON_DEBUG_CHIP is not set
689
-
690
-
#
691
-
# Misc devices
692
-
#
693
-
694
-
#
695
-
# Multimedia Capabilities Port drivers
696
-
#
697
-
698
-
#
699
-
# Multimedia devices
700
-
#
701
-
CONFIG_VIDEO_DEV=m
702
-
703
-
#
704
-
# Video For Linux
705
-
#
706
-
707
-
#
708
-
# Video Adapters
709
-
#
710
-
# CONFIG_VIDEO_CPIA is not set
711
-
# CONFIG_VIDEO_SAA5246A is not set
712
-
# CONFIG_VIDEO_SAA5249 is not set
713
-
# CONFIG_TUNER_3036 is not set
714
-
# CONFIG_VIDEO_OVCAMCHIP is not set
715
-
716
-
#
717
-
# Radio Adapters
718
-
#
719
-
# CONFIG_RADIO_MAESTRO is not set
720
-
721
-
#
722
-
# Digital Video Broadcasting Devices
723
-
#
724
-
# CONFIG_DVB is not set
725
-
726
-
#
727
-
# Graphics support
728
-
#
729
-
CONFIG_FB=y
730
-
CONFIG_FB_CFB_FILLRECT=y
731
-
CONFIG_FB_CFB_COPYAREA=y
732
-
CONFIG_FB_CFB_IMAGEBLIT=y
733
-
CONFIG_FB_SOFT_CURSOR=y
734
-
# CONFIG_FB_MACMODES is not set
735
-
CONFIG_FB_MODE_HELPERS=y
736
-
# CONFIG_FB_TILEBLITTING is not set
737
-
CONFIG_FB_PXA=y
738
-
# CONFIG_FB_W100 is not set
739
-
# CONFIG_FB_PXA_PARAMETERS is not set
740
-
# CONFIG_FB_S1D13XXX is not set
741
-
# CONFIG_FB_VIRTUAL is not set
742
-
743
-
#
744
-
# Console display driver support
745
-
#
746
-
# CONFIG_VGA_CONSOLE is not set
747
-
CONFIG_DUMMY_CONSOLE=y
748
-
CONFIG_FRAMEBUFFER_CONSOLE=y
749
-
CONFIG_FONTS=y
750
-
CONFIG_FONT_8x8=y
751
-
# CONFIG_FONT_8x16 is not set
752
-
# CONFIG_FONT_6x11 is not set
753
-
# CONFIG_FONT_7x14 is not set
754
-
# CONFIG_FONT_PEARL_8x8 is not set
755
-
# CONFIG_FONT_ACORN_8x8 is not set
756
-
# CONFIG_FONT_MINI_4x6 is not set
757
-
# CONFIG_FONT_SUN8x16 is not set
758
-
# CONFIG_FONT_SUN12x22 is not set
759
-
# CONFIG_FONT_10x18 is not set
760
-
761
-
#
762
-
# Logo configuration
763
-
#
764
-
# CONFIG_LOGO is not set
765
-
# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
766
-
767
-
#
768
-
# Sound
769
-
#
770
-
# CONFIG_SOUND is not set
771
-
772
-
#
773
-
# USB support
774
-
#
775
-
CONFIG_USB_ARCH_HAS_HCD=y
776
-
# CONFIG_USB_ARCH_HAS_OHCI is not set
777
-
# CONFIG_USB is not set
778
-
779
-
#
780
-
# USB Gadget Support
781
-
#
782
-
CONFIG_USB_GADGET=y
783
-
# CONFIG_USB_GADGET_DEBUG_FILES is not set
784
-
CONFIG_USB_GADGET_SELECTED=y
785
-
# CONFIG_USB_GADGET_NET2280 is not set
786
-
CONFIG_USB_GADGET_PXA2XX=y
787
-
CONFIG_USB_PXA2XX=y
788
-
# CONFIG_USB_PXA2XX_SMALL is not set
789
-
# CONFIG_USB_GADGET_GOKU is not set
790
-
# CONFIG_USB_GADGET_LH7A40X is not set
791
-
# CONFIG_USB_GADGET_OMAP is not set
792
-
# CONFIG_USB_GADGET_DUMMY_HCD is not set
793
-
# CONFIG_USB_GADGET_DUALSPEED is not set
794
-
# CONFIG_USB_ZERO is not set
795
-
CONFIG_USB_ETH=y
796
-
CONFIG_USB_ETH_RNDIS=y
797
-
# CONFIG_USB_GADGETFS is not set
798
-
# CONFIG_USB_FILE_STORAGE is not set
799
-
# CONFIG_USB_G_SERIAL is not set
800
-
801
-
#
802
-
# MMC/SD Card support
803
-
#
804
-
CONFIG_MMC=y
805
-
CONFIG_MMC_DEBUG=y
806
-
CONFIG_MMC_BLOCK=y
807
-
CONFIG_MMC_PXA=y
808
-
# CONFIG_MMC_WBSD is not set
809
-
810
-
#
811
-
# File systems
812
-
#
813
-
CONFIG_EXT2_FS=y
814
-
CONFIG_EXT2_FS_XATTR=y
815
-
CONFIG_EXT2_FS_POSIX_ACL=y
816
-
CONFIG_EXT2_FS_SECURITY=y
817
-
# CONFIG_EXT2_FS_XIP is not set
818
-
# CONFIG_EXT3_FS is not set
819
-
# CONFIG_JBD is not set
820
-
CONFIG_FS_MBCACHE=y
821
-
# CONFIG_REISERFS_FS is not set
822
-
# CONFIG_JFS_FS is not set
823
-
CONFIG_FS_POSIX_ACL=y
824
-
# CONFIG_XFS_FS is not set
825
-
# CONFIG_MINIX_FS is not set
826
-
# CONFIG_ROMFS_FS is not set
827
-
CONFIG_INOTIFY=y
828
-
# CONFIG_QUOTA is not set
829
-
CONFIG_DNOTIFY=y
830
-
# CONFIG_AUTOFS_FS is not set
831
-
# CONFIG_AUTOFS4_FS is not set
832
-
# CONFIG_FUSE_FS is not set
833
-
834
-
#
835
-
# CD-ROM/DVD Filesystems
836
-
#
837
-
# CONFIG_ISO9660_FS is not set
838
-
# CONFIG_UDF_FS is not set
839
-
840
-
#
841
-
# DOS/FAT/NT Filesystems
842
-
#
843
-
CONFIG_FAT_FS=y
844
-
CONFIG_MSDOS_FS=y
845
-
CONFIG_VFAT_FS=y
846
-
CONFIG_FAT_DEFAULT_CODEPAGE=437
847
-
CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
848
-
# CONFIG_NTFS_FS is not set
849
-
850
-
#
851
-
# Pseudo filesystems
852
-
#
853
-
CONFIG_PROC_FS=y
854
-
CONFIG_SYSFS=y
855
-
CONFIG_TMPFS=y
856
-
# CONFIG_HUGETLB_PAGE is not set
857
-
CONFIG_RAMFS=y
858
-
# CONFIG_RELAYFS_FS is not set
859
-
860
-
#
861
-
# Miscellaneous filesystems
862
-
#
863
-
# CONFIG_ADFS_FS is not set
864
-
# CONFIG_AFFS_FS is not set
865
-
# CONFIG_HFS_FS is not set
866
-
# CONFIG_HFSPLUS_FS is not set
867
-
# CONFIG_BEFS_FS is not set
868
-
# CONFIG_BFS_FS is not set
869
-
# CONFIG_EFS_FS is not set
870
-
# CONFIG_JFFS_FS is not set
871
-
CONFIG_JFFS2_FS=y
872
-
CONFIG_JFFS2_FS_DEBUG=0
873
-
CONFIG_JFFS2_FS_WRITEBUFFER=y
874
-
CONFIG_JFFS2_COMPRESSION_OPTIONS=y
875
-
CONFIG_JFFS2_ZLIB=y
876
-
CONFIG_JFFS2_RTIME=y
877
-
CONFIG_JFFS2_RUBIN=y
878
-
# CONFIG_JFFS2_CMODE_NONE is not set
879
-
CONFIG_JFFS2_CMODE_PRIORITY=y
880
-
# CONFIG_JFFS2_CMODE_SIZE is not set
881
-
CONFIG_CRAMFS=m
882
-
# CONFIG_VXFS_FS is not set
883
-
# CONFIG_HPFS_FS is not set
884
-
# CONFIG_QNX4FS_FS is not set
885
-
# CONFIG_SYSV_FS is not set
886
-
# CONFIG_UFS_FS is not set
887
-
888
-
#
889
-
# Network File Systems
890
-
#
891
-
# CONFIG_NFS_FS is not set
892
-
# CONFIG_NFSD is not set
893
-
# CONFIG_SMB_FS is not set
894
-
# CONFIG_CIFS is not set
895
-
# CONFIG_NCP_FS is not set
896
-
# CONFIG_CODA_FS is not set
897
-
# CONFIG_AFS_FS is not set
898
-
# CONFIG_9P_FS is not set
899
-
900
-
#
901
-
# Partition Types
902
-
#
903
-
CONFIG_PARTITION_ADVANCED=y
904
-
# CONFIG_ACORN_PARTITION is not set
905
-
# CONFIG_OSF_PARTITION is not set
906
-
# CONFIG_AMIGA_PARTITION is not set
907
-
# CONFIG_ATARI_PARTITION is not set
908
-
# CONFIG_MAC_PARTITION is not set
909
-
CONFIG_MSDOS_PARTITION=y
910
-
# CONFIG_BSD_DISKLABEL is not set
911
-
# CONFIG_MINIX_SUBPARTITION is not set
912
-
# CONFIG_SOLARIS_X86_PARTITION is not set
913
-
# CONFIG_UNIXWARE_DISKLABEL is not set
914
-
# CONFIG_LDM_PARTITION is not set
915
-
# CONFIG_SGI_PARTITION is not set
916
-
# CONFIG_ULTRIX_PARTITION is not set
917
-
# CONFIG_SUN_PARTITION is not set
918
-
# CONFIG_EFI_PARTITION is not set
919
-
920
-
#
921
-
# Native Language Support
922
-
#
923
-
CONFIG_NLS=y
924
-
CONFIG_NLS_DEFAULT="cp437"
925
-
CONFIG_NLS_CODEPAGE_437=y
926
-
# CONFIG_NLS_CODEPAGE_737 is not set
927
-
# CONFIG_NLS_CODEPAGE_775 is not set
928
-
# CONFIG_NLS_CODEPAGE_850 is not set
929
-
# CONFIG_NLS_CODEPAGE_852 is not set
930
-
# CONFIG_NLS_CODEPAGE_855 is not set
931
-
# CONFIG_NLS_CODEPAGE_857 is not set
932
-
# CONFIG_NLS_CODEPAGE_860 is not set
933
-
# CONFIG_NLS_CODEPAGE_861 is not set
934
-
# CONFIG_NLS_CODEPAGE_862 is not set
935
-
# CONFIG_NLS_CODEPAGE_863 is not set
936
-
# CONFIG_NLS_CODEPAGE_864 is not set
937
-
# CONFIG_NLS_CODEPAGE_865 is not set
938
-
# CONFIG_NLS_CODEPAGE_866 is not set
939
-
# CONFIG_NLS_CODEPAGE_869 is not set
940
-
# CONFIG_NLS_CODEPAGE_936 is not set
941
-
# CONFIG_NLS_CODEPAGE_950 is not set
942
-
# CONFIG_NLS_CODEPAGE_932 is not set
943
-
# CONFIG_NLS_CODEPAGE_949 is not set
944
-
# CONFIG_NLS_CODEPAGE_874 is not set
945
-
# CONFIG_NLS_ISO8859_8 is not set
946
-
# CONFIG_NLS_CODEPAGE_1250 is not set
947
-
# CONFIG_NLS_CODEPAGE_1251 is not set
948
-
CONFIG_NLS_ASCII=y
949
-
CONFIG_NLS_ISO8859_1=y
950
-
# CONFIG_NLS_ISO8859_2 is not set
951
-
# CONFIG_NLS_ISO8859_3 is not set
952
-
# CONFIG_NLS_ISO8859_4 is not set
953
-
# CONFIG_NLS_ISO8859_5 is not set
954
-
# CONFIG_NLS_ISO8859_6 is not set
955
-
# CONFIG_NLS_ISO8859_7 is not set
956
-
# CONFIG_NLS_ISO8859_9 is not set
957
-
# CONFIG_NLS_ISO8859_13 is not set
958
-
# CONFIG_NLS_ISO8859_14 is not set
959
-
# CONFIG_NLS_ISO8859_15 is not set
960
-
# CONFIG_NLS_KOI8_R is not set
961
-
# CONFIG_NLS_KOI8_U is not set
962
-
CONFIG_NLS_UTF8=y
963
-
964
-
#
965
-
# Profiling support
966
-
#
967
-
# CONFIG_PROFILING is not set
968
-
969
-
#
970
-
# Kernel hacking
971
-
#
972
-
# CONFIG_PRINTK_TIME is not set
973
-
CONFIG_DEBUG_KERNEL=y
974
-
CONFIG_MAGIC_SYSRQ=y
975
-
CONFIG_LOG_BUF_SHIFT=14
976
-
CONFIG_DETECT_SOFTLOCKUP=y
977
-
# CONFIG_SCHEDSTATS is not set
978
-
# CONFIG_DEBUG_SLAB is not set
979
-
CONFIG_DEBUG_PREEMPT=y
980
-
# CONFIG_DEBUG_SPINLOCK is not set
981
-
# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
982
-
# CONFIG_DEBUG_KOBJECT is not set
983
-
# CONFIG_DEBUG_BUGVERBOSE is not set
984
-
# CONFIG_DEBUG_INFO is not set
985
-
# CONFIG_DEBUG_FS is not set
986
-
CONFIG_FRAME_POINTER=y
987
-
# CONFIG_DEBUG_USER is not set
988
-
# CONFIG_DEBUG_WAITQ is not set
989
-
CONFIG_DEBUG_ERRORS=y
990
-
# CONFIG_DEBUG_LL is not set
991
-
992
-
#
993
-
# Security options
994
-
#
995
-
# CONFIG_KEYS is not set
996
-
# CONFIG_SECURITY is not set
997
-
998
-
#
999
-
# Cryptographic options
1000
-
#
1001
-
# CONFIG_CRYPTO is not set
1002
-
1003
-
#
1004
-
# Hardware crypto devices
1005
-
#
1006
-
1007
-
#
1008
-
# Library routines
1009
-
#
1010
-
CONFIG_CRC_CCITT=y
1011
-
# CONFIG_CRC16 is not set
1012
-
CONFIG_CRC32=y
1013
-
# CONFIG_LIBCRC32C is not set
1014
-
CONFIG_ZLIB_INFLATE=y
1015
-
CONFIG_ZLIB_DEFLATE=y
+64
-21
arch/arm/configs/spitz_defconfig
+64
-21
arch/arm/configs/spitz_defconfig
···
1
1
#
2
2
# Automatically generated make config: don't edit
3
-
# Linux kernel version: 2.6.14-rc3
4
-
# Sun Oct 9 17:11:19 2005
3
+
# Linux kernel version: 2.6.15-rc2
4
+
# Mon Nov 28 10:26:52 2005
5
5
#
6
6
CONFIG_ARM=y
7
7
CONFIG_MMU=y
···
64
64
CONFIG_KMOD=y
65
65
66
66
#
67
+
# Block layer
68
+
#
69
+
70
+
#
71
+
# IO Schedulers
72
+
#
73
+
CONFIG_IOSCHED_NOOP=y
74
+
CONFIG_IOSCHED_AS=y
75
+
CONFIG_IOSCHED_DEADLINE=y
76
+
CONFIG_IOSCHED_CFQ=y
77
+
CONFIG_DEFAULT_AS=y
78
+
# CONFIG_DEFAULT_DEADLINE is not set
79
+
# CONFIG_DEFAULT_CFQ is not set
80
+
# CONFIG_DEFAULT_NOOP is not set
81
+
CONFIG_DEFAULT_IOSCHED="anticipatory"
82
+
83
+
#
67
84
# System Type
68
85
#
69
86
# CONFIG_ARCH_CLPS7500 is not set
···
102
85
# CONFIG_ARCH_LH7A40X is not set
103
86
# CONFIG_ARCH_OMAP is not set
104
87
# CONFIG_ARCH_VERSATILE is not set
88
+
# CONFIG_ARCH_REALVIEW is not set
105
89
# CONFIG_ARCH_IMX is not set
106
90
# CONFIG_ARCH_H720X is not set
107
91
# CONFIG_ARCH_AAEC2000 is not set
···
116
98
CONFIG_PXA_SHARPSL=y
117
99
# CONFIG_PXA_SHARPSL_25x is not set
118
100
CONFIG_PXA_SHARPSL_27x=y
101
+
CONFIG_MACH_AKITA=y
119
102
CONFIG_MACH_SPITZ=y
120
103
CONFIG_MACH_BORZOI=y
121
104
CONFIG_PXA27x=y
105
+
CONFIG_IWMMXT=y
122
106
CONFIG_PXA_SHARP_Cxx00=y
107
+
CONFIG_PXA_SSP=y
123
108
124
109
#
125
110
# Processor Type
···
174
153
CONFIG_FLATMEM=y
175
154
CONFIG_FLAT_NODE_MEM_MAP=y
176
155
# CONFIG_SPARSEMEM_STATIC is not set
156
+
CONFIG_SPLIT_PTLOCK_CPUS=4096
177
157
CONFIG_ALIGNMENT_TRAP=y
178
158
179
159
#
···
255
233
CONFIG_IPV6_TUNNEL=m
256
234
CONFIG_NETFILTER=y
257
235
# CONFIG_NETFILTER_DEBUG is not set
236
+
237
+
#
238
+
# Core Netfilter Configuration
239
+
#
258
240
# CONFIG_NETFILTER_NETLINK is not set
259
241
260
242
#
···
380
354
# CONFIG_NET_DIVERT is not set
381
355
# CONFIG_ECONET is not set
382
356
# CONFIG_WAN_ROUTER is not set
357
+
358
+
#
359
+
# QoS and/or fair queueing
360
+
#
383
361
# CONFIG_NET_SCHED is not set
384
362
CONFIG_NET_CLS_ROUTE=y
385
363
···
441
411
# CONFIG_SMC_IRCC_FIR is not set
442
412
# CONFIG_ALI_FIR is not set
443
413
# CONFIG_VIA_FIR is not set
414
+
CONFIG_PXA_FICP=m
444
415
CONFIG_BT=m
445
416
CONFIG_BT_L2CAP=m
446
417
CONFIG_BT_SCO=m
···
460
429
CONFIG_BT_HCIUART=m
461
430
CONFIG_BT_HCIUART_H4=y
462
431
CONFIG_BT_HCIUART_BCSP=y
463
-
CONFIG_BT_HCIUART_BCSP_TXCRC=y
464
432
CONFIG_BT_HCIBCM203X=m
465
433
CONFIG_BT_HCIBPA10X=m
466
434
CONFIG_BT_HCIBFUSB=m
···
487
457
# CONFIG_DEBUG_DRIVER is not set
488
458
489
459
#
460
+
# Connector - unified userspace <-> kernelspace linker
461
+
#
462
+
# CONFIG_CONNECTOR is not set
463
+
464
+
#
490
465
# Memory Technology Devices (MTD)
491
466
#
492
467
CONFIG_MTD=y
···
510
475
# CONFIG_FTL is not set
511
476
# CONFIG_NFTL is not set
512
477
# CONFIG_INFTL is not set
478
+
# CONFIG_RFD_FTL is not set
513
479
514
480
#
515
481
# RAM/ROM/Flash chip drivers
···
566
530
# CONFIG_MTD_NAND_NANDSIM is not set
567
531
568
532
#
533
+
# OneNAND Flash Device Drivers
534
+
#
535
+
# CONFIG_MTD_ONENAND is not set
536
+
537
+
#
569
538
# Parallel port support
570
539
#
571
540
# CONFIG_PARPORT is not set
···
590
549
# CONFIG_BLK_DEV_RAM is not set
591
550
CONFIG_BLK_DEV_RAM_COUNT=16
592
551
# CONFIG_CDROM_PKTCDVD is not set
593
-
594
-
#
595
-
# IO Schedulers
596
-
#
597
-
CONFIG_IOSCHED_NOOP=y
598
-
CONFIG_IOSCHED_AS=y
599
-
CONFIG_IOSCHED_DEADLINE=y
600
-
CONFIG_IOSCHED_CFQ=y
601
552
# CONFIG_ATA_OVER_ETH is not set
602
553
603
554
#
···
656
623
#
657
624
# SCSI low-level drivers
658
625
#
626
+
# CONFIG_ISCSI_TCP is not set
659
627
# CONFIG_SCSI_SATA is not set
660
628
# CONFIG_SCSI_DEBUG is not set
661
629
···
780
746
# CONFIG_PPP_SYNC_TTY is not set
781
747
# CONFIG_PPP_DEFLATE is not set
782
748
CONFIG_PPP_BSDCOMP=m
749
+
# CONFIG_PPP_MPPE is not set
783
750
# CONFIG_PPPOE is not set
784
751
# CONFIG_SLIP is not set
785
752
# CONFIG_SHAPER is not set
···
806
771
# CONFIG_INPUT_TSDEV is not set
807
772
CONFIG_INPUT_EVDEV=y
808
773
# CONFIG_INPUT_EVBUG is not set
774
+
# CONFIG_INPUT_POWER is not set
809
775
810
776
#
811
777
# Input Device Drivers
···
884
848
# PCMCIA character devices
885
849
#
886
850
# CONFIG_SYNCLINK_CS is not set
851
+
# CONFIG_CARDMAN_4000 is not set
852
+
# CONFIG_CARDMAN_4040 is not set
887
853
# CONFIG_RAW_DRIVER is not set
888
854
889
855
#
890
856
# TPM devices
891
857
#
858
+
# CONFIG_TCG_TPM is not set
859
+
# CONFIG_TELCLOCK is not set
892
860
893
861
#
894
862
# I2C support
···
931
891
CONFIG_FB_CFB_FILLRECT=y
932
892
CONFIG_FB_CFB_COPYAREA=y
933
893
CONFIG_FB_CFB_IMAGEBLIT=y
934
-
CONFIG_FB_SOFT_CURSOR=y
935
894
# CONFIG_FB_MACMODES is not set
936
895
# CONFIG_FB_MODE_HELPERS is not set
937
896
# CONFIG_FB_TILEBLITTING is not set
938
-
CONFIG_FB_PXA=y
939
-
# CONFIG_FB_W100 is not set
940
-
# CONFIG_FB_PXA_PARAMETERS is not set
941
897
# CONFIG_FB_S1D13XXX is not set
898
+
CONFIG_FB_PXA=y
899
+
# CONFIG_FB_PXA_PARAMETERS is not set
900
+
# CONFIG_FB_W100 is not set
942
901
# CONFIG_FB_VIRTUAL is not set
943
902
944
903
#
···
946
907
# CONFIG_VGA_CONSOLE is not set
947
908
CONFIG_DUMMY_CONSOLE=y
948
909
CONFIG_FRAMEBUFFER_CONSOLE=y
910
+
CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
949
911
CONFIG_FONTS=y
950
912
CONFIG_FONT_8x8=y
951
913
CONFIG_FONT_8x16=y
···
1005
965
#
1006
966
# USB Device Class drivers
1007
967
#
1008
-
1009
-
#
1010
-
# USB Bluetooth TTY can only be used with disabled Bluetooth subsystem
1011
-
#
1012
968
CONFIG_USB_ACM=m
1013
969
CONFIG_USB_PRINTER=m
1014
970
1015
971
#
1016
-
# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
972
+
# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
973
+
#
974
+
975
+
#
976
+
# may also be needed; see USB_STORAGE Help for more information
1017
977
#
1018
978
CONFIG_USB_STORAGE=m
1019
979
# CONFIG_USB_STORAGE_DEBUG is not set
···
1025
985
# CONFIG_USB_STORAGE_SDDR09 is not set
1026
986
# CONFIG_USB_STORAGE_SDDR55 is not set
1027
987
# CONFIG_USB_STORAGE_JUMPSHOT is not set
1028
-
# CONFIG_USB_STORAGE_ONETOUCH is not set
1029
988
1030
989
#
1031
990
# USB Input Devices
···
1097
1058
CONFIG_USB_SERIAL=m
1098
1059
CONFIG_USB_SERIAL_GENERIC=y
1099
1060
# CONFIG_USB_SERIAL_AIRPRIME is not set
1061
+
# CONFIG_USB_SERIAL_ANYDATA is not set
1100
1062
CONFIG_USB_SERIAL_BELKIN=m
1101
1063
# CONFIG_USB_SERIAL_WHITEHEAT is not set
1102
1064
CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m
···
1258
1218
CONFIG_JFFS2_FS=y
1259
1219
CONFIG_JFFS2_FS_DEBUG=0
1260
1220
CONFIG_JFFS2_FS_WRITEBUFFER=y
1221
+
CONFIG_JFFS2_SUMMARY=y
1261
1222
CONFIG_JFFS2_COMPRESSION_OPTIONS=y
1262
1223
CONFIG_JFFS2_ZLIB=y
1263
1224
CONFIG_JFFS2_RTIME=y
···
1385
1344
CONFIG_DEBUG_BUGVERBOSE=y
1386
1345
# CONFIG_DEBUG_INFO is not set
1387
1346
# CONFIG_DEBUG_FS is not set
1347
+
# CONFIG_DEBUG_VM is not set
1388
1348
CONFIG_FRAME_POINTER=y
1349
+
# CONFIG_RCU_TORTURE_TEST is not set
1389
1350
# CONFIG_DEBUG_USER is not set
1390
1351
# CONFIG_DEBUG_WAITQ is not set
1391
1352
CONFIG_DEBUG_ERRORS=y
+3
-8
arch/arm/kernel/head.S
+3
-8
arch/arm/kernel/head.S
···
17
17
18
18
#include <asm/assembler.h>
19
19
#include <asm/domain.h>
20
-
#include <asm/mach-types.h>
21
20
#include <asm/procinfo.h>
22
21
#include <asm/ptrace.h>
23
22
#include <asm/asm-offsets.h>
···
82
83
@ and irqs disabled
83
84
bl __lookup_processor_type @ r5=procinfo r9=cpuid
84
85
movs r10, r5 @ invalid processor (r5=0)?
85
-
beq __error_p @ yes, error 'p'
86
+
beq __error_p @ yes, error 'p'
86
87
bl __lookup_machine_type @ r5=machinfo
87
88
movs r8, r5 @ invalid machine (r5=0)?
88
89
beq __error_a @ yes, error 'a'
···
342
343
bne 1b
343
344
#if defined(CONFIG_ARCH_NETWINDER) || defined(CONFIG_ARCH_CATS)
344
345
/*
345
-
* If we're using the NetWinder, we need to map in
346
-
* the 16550-type serial port for the debug messages
346
+
* If we're using the NetWinder or CATS, we also need to map
347
+
* in the 16550-type serial port for the debug messages
347
348
*/
348
-
teq r1, #MACH_TYPE_NETWINDER
349
-
teqne r1, #MACH_TYPE_CATS
350
-
bne 1f
351
349
add r0, r4, #0xff000000 >> 18
352
350
orr r3, r7, #0x7c000000
353
351
str r3, [r0]
354
-
1:
355
352
#endif
356
353
#ifdef CONFIG_ARCH_RPC
357
354
/*
+2
-2
arch/arm/mach-pxa/Kconfig
+2
-2
arch/arm/mach-pxa/Kconfig
···
44
44
config PXA_SHARPSL_27x
45
45
bool "Sharp PXA270 models (SL-Cxx00)"
46
46
select PXA27x
47
+
select IWMMXT
47
48
48
49
endchoice
49
50
···
61
60
bool "Enable Sharp SL-C700 (Corgi) Support"
62
61
depends PXA_SHARPSL_25x
63
62
select PXA_SHARP_C7xx
64
-
select PXA_SSP
65
63
66
64
config MACH_SHEPHERD
67
65
bool "Enable Sharp SL-C750 (Shepherd) Support"
···
90
90
91
91
config MACH_TOSA
92
92
bool "Enable Sharp SL-6000x (Tosa) Support"
93
-
depends PXA_SHARPSL
93
+
depends PXA_SHARPSL_25x
94
94
95
95
config PXA25x
96
96
bool
-1
arch/arm/mach-realview/core.c
-1
arch/arm/mach-realview/core.c
+10
-3
arch/arm/mm/consistent.c
+10
-3
arch/arm/mm/consistent.c
···
66
66
unsigned long vm_start;
67
67
unsigned long vm_end;
68
68
struct page *vm_pages;
69
+
int vm_active;
69
70
};
70
71
71
72
static struct vm_region consistent_head = {
···
105
104
list_add_tail(&new->vm_list, &c->vm_list);
106
105
new->vm_start = addr;
107
106
new->vm_end = addr + size;
107
+
new->vm_active = 1;
108
108
109
109
spin_unlock_irqrestore(&consistent_lock, flags);
110
110
return new;
···
122
120
struct vm_region *c;
123
121
124
122
list_for_each_entry(c, &head->vm_list, vm_list) {
125
-
if (c->vm_start == addr)
123
+
if (c->vm_active && c->vm_start == addr)
126
124
goto out;
127
125
}
128
126
c = NULL;
···
321
319
322
320
/*
323
321
* free a page as defined by the above mapping.
322
+
* Must not be called with IRQs disabled.
324
323
*/
325
324
void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr_t handle)
326
325
{
···
329
326
unsigned long flags, addr;
330
327
pte_t *ptep;
331
328
329
+
WARN_ON(irqs_disabled());
330
+
332
331
size = PAGE_ALIGN(size);
333
332
334
333
spin_lock_irqsave(&consistent_lock, flags);
335
-
336
334
c = vm_region_find(&consistent_head, (unsigned long)cpu_addr);
337
335
if (!c)
338
336
goto no_area;
337
+
338
+
c->vm_active = 0;
339
+
spin_unlock_irqrestore(&consistent_lock, flags);
339
340
340
341
if ((c->vm_end - c->vm_start) != size) {
341
342
printk(KERN_ERR "%s: freeing wrong coherent size (%ld != %d)\n",
···
379
372
380
373
flush_tlb_kernel_range(c->vm_start, c->vm_end);
381
374
375
+
spin_lock_irqsave(&consistent_lock, flags);
382
376
list_del(&c->vm_list);
383
-
384
377
spin_unlock_irqrestore(&consistent_lock, flags);
385
378
386
379
kfree(c);
+10
-4
arch/arm/tools/mach-types
+10
-4
arch/arm/tools/mach-types
···
12
12
#
13
13
# http://www.arm.linux.org.uk/developer/machines/?action=new
14
14
#
15
-
# Last update: Fri Nov 11 21:55:04 2005
15
+
# Last update: Fri Nov 25 14:43:04 2005
16
16
#
17
17
# machine_is_xxx CONFIG_xxxx MACH_TYPE_xxx number
18
18
#
···
857
857
maestro MACH_MAESTRO MAESTRO 843
858
858
tunge2 MACH_TUNGE2 TUNGE2 844
859
859
ixbbm MACH_IXBBM IXBBM 845
860
-
mx27 MACH_MX27 MX27 846
860
+
mx27ads MACH_MX27 MX27 846
861
861
ax8004 MACH_AX8004 AX8004 847
862
862
at91sam9261ek MACH_AT91SAM9261EK AT91SAM9261EK 848
863
863
loft MACH_LOFT LOFT 849
864
864
magpie MACH_MAGPIE MAGPIE 850
865
-
mx21 MACH_MX21 MX21 851
865
+
mx21ads MACH_MX21 MX21 851
866
866
mb87m3400 MACH_MB87M3400 MB87M3400 852
867
867
mguard_delta MACH_MGUARD_DELTA MGUARD_DELTA 853
868
868
davinci_dvdp MACH_DAVINCI_DVDP DAVINCI_DVDP 854
···
897
897
mx21civ MACH_MX21CIV MX21CIV 883
898
898
mahi_cdac MACH_MAHI_CDAC MAHI_CDAC 884
899
899
xscale_palmtx MACH_XSCALE_PALMTX XSCALE_PALMTX 885
900
-
arch_s3c2413 MACH_ARCH_S3C2413 ARCH_S3C2413 886
901
900
s3c2413 MACH_S3C2413 S3C2413 887
902
901
samsys_ep0 MACH_SAMSYS_EP0 SAMSYS_EP0 888
903
902
wg302v1 MACH_WG302V1 WG302V1 889
904
903
wg302v2 MACH_WG302V2 WG302V2 890
905
904
eb42x MACH_EB42X EB42X 891
906
905
iq331es MACH_IQ331ES IQ331ES 892
906
+
cosydsp MACH_COSYDSP COSYDSP 893
907
+
uplat7d MACH_UPLAT7D UPLAT7D 894
908
+
ptdavinci MACH_PTDAVINCI PTDAVINCI 895
909
+
mbus MACH_MBUS MBUS 896
910
+
nadia2vb MACH_NADIA2VB NADIA2VB 897
911
+
r1000 MACH_R1000 R1000 898
912
+
hw90250 MACH_HW90250 HW90250 899
+1
-1
arch/frv/kernel/semaphore.c
+1
-1
arch/frv/kernel/semaphore.c
+1
-1
arch/frv/mb93090-mb00/pci-irq.c
+1
-1
arch/frv/mb93090-mb00/pci-irq.c
+1
-1
arch/frv/mm/init.c
+1
-1
arch/frv/mm/init.c
+3
-3
arch/frv/mm/pgalloc.c
+3
-3
arch/frv/mm/pgalloc.c
···
85
85
struct page *page = virt_to_page(pgd);
86
86
page->index = (unsigned long) pgd_list;
87
87
if (pgd_list)
88
-
pgd_list->private = (unsigned long) &page->index;
88
+
set_page_private(pgd_list, (unsigned long) &page->index);
89
89
pgd_list = page;
90
90
set_page_private(page, (unsigned long)&pgd_list);
91
91
}
···
94
94
{
95
95
struct page *next, **pprev, *page = virt_to_page(pgd);
96
96
next = (struct page *) page->index;
97
-
pprev = (struct page **)page_private(page);
97
+
pprev = (struct page **) page_private(page);
98
98
*pprev = next;
99
99
if (next)
100
-
next->private = (unsigned long) pprev;
100
+
set_page_private(next, (unsigned long) pprev);
101
101
}
102
102
103
103
void pgd_ctor(void *pgd, kmem_cache_t *cache, unsigned long unused)
+2
-2
arch/i386/kernel/io_apic.c
+2
-2
arch/i386/kernel/io_apic.c
···
2009
2009
{
2010
2010
int irq = vector_to_irq(vector);
2011
2011
2012
-
move_irq(vector);
2012
+
move_native_irq(vector);
2013
2013
ack_edge_ioapic_irq(irq);
2014
2014
}
2015
2015
···
2024
2024
{
2025
2025
int irq = vector_to_irq(vector);
2026
2026
2027
-
move_irq(vector);
2027
+
move_native_irq(vector);
2028
2028
end_level_ioapic_irq(irq);
2029
2029
}
2030
2030
+8
arch/i386/kernel/reboot.c
+8
arch/i386/kernel/reboot.c
···
111
111
DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
112
112
},
113
113
},
114
+
{ /* Handle problems with rebooting on HP nc6120 */
115
+
.callback = set_bios_reboot,
116
+
.ident = "HP Compaq nc6120",
117
+
.matches = {
118
+
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
119
+
DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nc6120"),
120
+
},
121
+
},
114
122
{ }
115
123
};
116
124
+1
arch/ia64/kernel/ia64_ksyms.c
+1
arch/ia64/kernel/ia64_ksyms.c
+1
-1
arch/ia64/kernel/kprobes.c
+1
-1
arch/ia64/kernel/kprobes.c
···
740
740
switch(val) {
741
741
case DIE_BREAK:
742
742
/* err is break number from ia64_bad_break() */
743
-
if (args->err == 0x80200 || args->err == 0x80300)
743
+
if (args->err == 0x80200 || args->err == 0x80300 || args->err == 0)
744
744
if (pre_kprobes_handler(args))
745
745
ret = NOTIFY_STOP;
746
746
break;
-18
arch/ia64/kernel/traps.c
-18
arch/ia64/kernel/traps.c
···
132
132
siginfo_t siginfo;
133
133
int sig, code;
134
134
135
-
/* break.b always sets cr.iim to 0, which causes problems for
136
-
* debuggers. Get the real break number from the original instruction,
137
-
* but only for kernel code. User space break.b is left alone, to
138
-
* preserve the existing behaviour. All break codings have the same
139
-
* format, so there is no need to check the slot type.
140
-
*/
141
-
if (break_num == 0 && !user_mode(regs)) {
142
-
struct ia64_psr *ipsr = ia64_psr(regs);
143
-
unsigned long *bundle = (unsigned long *)regs->cr_iip;
144
-
unsigned long slot;
145
-
switch (ipsr->ri) {
146
-
case 0: slot = (bundle[0] >> 5); break;
147
-
case 1: slot = (bundle[0] >> 46) | (bundle[1] << 18); break;
148
-
default: slot = (bundle[1] >> 23); break;
149
-
}
150
-
break_num = ((slot >> 36 & 1) << 20) | (slot >> 6 & 0xfffff);
151
-
}
152
-
153
135
/* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
154
136
siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
155
137
siginfo.si_imm = break_num;
+37
-17
arch/m32r/kernel/io_mappi3.c
+37
-17
arch/m32r/kernel/io_mappi3.c
···
36
36
return (void *)(port + NONCACHE_OFFSET);
37
37
}
38
38
39
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
39
+
#if defined(CONFIG_IDE)
40
40
static inline void *__port2addr_ata(unsigned long port)
41
41
{
42
42
static int dummy_reg;
43
43
44
44
switch (port) {
45
+
/* IDE0 CF */
45
46
case 0x1f0: return (void *)0xb4002000;
46
47
case 0x1f1: return (void *)0xb4012800;
47
48
case 0x1f2: return (void *)0xb4012002;
···
52
51
case 0x1f6: return (void *)0xb4012006;
53
52
case 0x1f7: return (void *)0xb4012806;
54
53
case 0x3f6: return (void *)0xb401200e;
54
+
/* IDE1 IDE */
55
+
case 0x170: return (void *)0xb4810000; /* Data 16bit */
56
+
case 0x171: return (void *)0xb4810002; /* Features / Error */
57
+
case 0x172: return (void *)0xb4810004; /* Sector count */
58
+
case 0x173: return (void *)0xb4810006; /* Sector number */
59
+
case 0x174: return (void *)0xb4810008; /* Cylinder low */
60
+
case 0x175: return (void *)0xb481000a; /* Cylinder high */
61
+
case 0x176: return (void *)0xb481000c; /* Device head */
62
+
case 0x177: return (void *)0xb481000e; /* Command */
63
+
case 0x376: return (void *)0xb480800c; /* Device control / Alt status */
64
+
55
65
default: return (void *)&dummy_reg;
56
66
}
57
67
}
···
120
108
{
121
109
if (port >= LAN_IOSTART && port < LAN_IOEND)
122
110
return _ne_inb(PORT2ADDR_NE(port));
123
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
124
-
else if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
111
+
#if defined(CONFIG_IDE)
112
+
else if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
113
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
125
114
return *(volatile unsigned char *)__port2addr_ata(port);
126
115
}
127
116
#endif
···
140
127
{
141
128
if (port >= LAN_IOSTART && port < LAN_IOEND)
142
129
return _ne_inw(PORT2ADDR_NE(port));
143
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
144
-
else if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
130
+
#if defined(CONFIG_IDE)
131
+
else if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
132
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
145
133
return *(volatile unsigned short *)__port2addr_ata(port);
146
134
}
147
135
#endif
···
199
185
if (port >= LAN_IOSTART && port < LAN_IOEND)
200
186
_ne_outb(b, PORT2ADDR_NE(port));
201
187
else
202
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
203
-
if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
188
+
#if defined(CONFIG_IDE)
189
+
if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
190
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
204
191
*(volatile unsigned char *)__port2addr_ata(port) = b;
205
192
} else
206
193
#endif
···
218
203
if (port >= LAN_IOSTART && port < LAN_IOEND)
219
204
_ne_outw(w, PORT2ADDR_NE(port));
220
205
else
221
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
222
-
if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
206
+
#if defined(CONFIG_IDE)
207
+
if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
208
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
223
209
*(volatile unsigned short *)__port2addr_ata(port) = w;
224
210
} else
225
211
#endif
···
269
253
{
270
254
if (port >= LAN_IOSTART && port < LAN_IOEND)
271
255
_ne_insb(PORT2ADDR_NE(port), addr, count);
272
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
273
-
else if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
256
+
#if defined(CONFIG_IDE)
257
+
else if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
258
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
274
259
unsigned char *buf = addr;
275
260
unsigned char *portp = __port2addr_ata(port);
276
261
while (count--)
···
306
289
pcc_ioread_word(9, port, (void *)addr, sizeof(unsigned short),
307
290
count, 1);
308
291
#endif
309
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
310
-
} else if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
292
+
#if defined(CONFIG_IDE)
293
+
} else if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
294
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
311
295
portp = __port2addr_ata(port);
312
296
while (count--)
313
297
*buf++ = *(volatile unsigned short *)portp;
···
339
321
portp = PORT2ADDR_NE(port);
340
322
while (count--)
341
323
_ne_outb(*buf++, portp);
342
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
343
-
} else if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
324
+
#if defined(CONFIG_IDE)
325
+
} else if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
326
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
344
327
portp = __port2addr_ata(port);
345
328
while (count--)
346
329
*(volatile unsigned char *)portp = *buf++;
···
367
348
portp = PORT2ADDR_NE(port);
368
349
while (count--)
369
350
*(volatile unsigned short *)portp = *buf++;
370
-
#if defined(CONFIG_IDE) && !defined(CONFIG_M32R_CFC)
371
-
} else if ((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) {
351
+
#if defined(CONFIG_IDE)
352
+
} else if ( ((port >= 0x170 && port <=0x177) || port == 0x376) ||
353
+
((port >= 0x1f0 && port <=0x1f7) || port == 0x3f6) ){
372
354
portp = __port2addr_ata(port);
373
355
while (count--)
374
356
*(volatile unsigned short *)portp = *buf++;
+11
-9
arch/m32r/kernel/setup_mappi3.c
+11
-9
arch/m32r/kernel/setup_mappi3.c
···
151
151
disable_mappi3_irq(M32R_IRQ_INT1);
152
152
#endif /* CONFIG_USB */
153
153
154
-
/* ICUCR40: CFC IREQ */
154
+
/* CFC IREQ */
155
155
irq_desc[PLD_IRQ_CFIREQ].status = IRQ_DISABLED;
156
156
irq_desc[PLD_IRQ_CFIREQ].handler = &mappi3_irq_type;
157
157
irq_desc[PLD_IRQ_CFIREQ].action = 0;
···
160
160
disable_mappi3_irq(PLD_IRQ_CFIREQ);
161
161
162
162
#if defined(CONFIG_M32R_CFC)
163
-
/* ICUCR41: CFC Insert */
163
+
/* ICUCR41: CFC Insert & eject */
164
164
irq_desc[PLD_IRQ_CFC_INSERT].status = IRQ_DISABLED;
165
165
irq_desc[PLD_IRQ_CFC_INSERT].handler = &mappi3_irq_type;
166
166
irq_desc[PLD_IRQ_CFC_INSERT].action = 0;
···
168
168
icu_data[PLD_IRQ_CFC_INSERT].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD00;
169
169
disable_mappi3_irq(PLD_IRQ_CFC_INSERT);
170
170
171
-
/* ICUCR42: CFC Eject */
172
-
irq_desc[PLD_IRQ_CFC_EJECT].status = IRQ_DISABLED;
173
-
irq_desc[PLD_IRQ_CFC_EJECT].handler = &mappi3_irq_type;
174
-
irq_desc[PLD_IRQ_CFC_EJECT].action = 0;
175
-
irq_desc[PLD_IRQ_CFC_EJECT].depth = 1; /* disable nested irq */
176
-
icu_data[PLD_IRQ_CFC_EJECT].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
177
-
disable_mappi3_irq(PLD_IRQ_CFC_EJECT);
178
171
#endif /* CONFIG_M32R_CFC */
172
+
173
+
/* IDE IREQ */
174
+
irq_desc[PLD_IRQ_IDEIREQ].status = IRQ_DISABLED;
175
+
irq_desc[PLD_IRQ_IDEIREQ].handler = &mappi3_irq_type;
176
+
irq_desc[PLD_IRQ_IDEIREQ].action = 0;
177
+
irq_desc[PLD_IRQ_IDEIREQ].depth = 1; /* disable nested irq */
178
+
icu_data[PLD_IRQ_IDEIREQ].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
179
+
disable_mappi3_irq(PLD_IRQ_IDEIREQ);
180
+
179
181
}
180
182
181
183
#if defined(CONFIG_SMC91X)
+4
-2
arch/m32r/kernel/sys_m32r.c
+4
-2
arch/m32r/kernel/sys_m32r.c
···
41
41
return -EFAULT;
42
42
local_irq_save(flags);
43
43
oldval = *addr;
44
-
*addr = 1;
44
+
if (!oldval)
45
+
*addr = 1;
45
46
local_irq_restore(flags);
46
47
return oldval;
47
48
}
···
60
59
61
60
_raw_spin_lock(&tas_lock);
62
61
oldval = *addr;
63
-
*addr = 1;
62
+
if (!oldval)
63
+
*addr = 1;
64
64
_raw_spin_unlock(&tas_lock);
65
65
66
66
return oldval;
+2
-4
arch/powerpc/kernel/ppc_ksyms.c
+2
-4
arch/powerpc/kernel/ppc_ksyms.c
···
163
163
EXPORT_SYMBOL(giveup_spe);
164
164
#endif /* CONFIG_SPE */
165
165
166
-
#ifdef CONFIG_PPC64
167
-
EXPORT_SYMBOL(__flush_icache_range);
168
-
#else
166
+
#ifndef CONFIG_PPC64
169
167
EXPORT_SYMBOL(flush_instruction_cache);
170
-
EXPORT_SYMBOL(flush_icache_range);
171
168
EXPORT_SYMBOL(flush_tlb_kernel_range);
172
169
EXPORT_SYMBOL(flush_tlb_page);
173
170
EXPORT_SYMBOL(_tlbie);
174
171
#endif
172
+
EXPORT_SYMBOL(__flush_icache_range);
175
173
EXPORT_SYMBOL(flush_dcache_range);
176
174
177
175
#ifdef CONFIG_SMP
+25
-37
arch/powerpc/kernel/process.c
+25
-37
arch/powerpc/kernel/process.c
···
201
201
}
202
202
#endif /* CONFIG_SPE */
203
203
204
+
/*
205
+
* If we are doing lazy switching of CPU state (FP, altivec or SPE),
206
+
* and the current task has some state, discard it.
207
+
*/
208
+
static inline void discard_lazy_cpu_state(void)
209
+
{
210
+
#ifndef CONFIG_SMP
211
+
preempt_disable();
212
+
if (last_task_used_math == current)
213
+
last_task_used_math = NULL;
214
+
#ifdef CONFIG_ALTIVEC
215
+
if (last_task_used_altivec == current)
216
+
last_task_used_altivec = NULL;
217
+
#endif /* CONFIG_ALTIVEC */
218
+
#ifdef CONFIG_SPE
219
+
if (last_task_used_spe == current)
220
+
last_task_used_spe = NULL;
221
+
#endif
222
+
preempt_enable();
223
+
#endif /* CONFIG_SMP */
224
+
}
225
+
204
226
int set_dabr(unsigned long dabr)
205
227
{
206
228
if (ppc_md.set_dabr)
···
456
434
void exit_thread(void)
457
435
{
458
436
kprobe_flush_task(current);
459
-
460
-
#ifndef CONFIG_SMP
461
-
if (last_task_used_math == current)
462
-
last_task_used_math = NULL;
463
-
#ifdef CONFIG_ALTIVEC
464
-
if (last_task_used_altivec == current)
465
-
last_task_used_altivec = NULL;
466
-
#endif /* CONFIG_ALTIVEC */
467
-
#ifdef CONFIG_SPE
468
-
if (last_task_used_spe == current)
469
-
last_task_used_spe = NULL;
470
-
#endif
471
-
#endif /* CONFIG_SMP */
437
+
discard_lazy_cpu_state();
472
438
}
473
439
474
440
void flush_thread(void)
···
468
458
t->flags ^= (_TIF_ABI_PENDING | _TIF_32BIT);
469
459
#endif
470
460
471
-
#ifndef CONFIG_SMP
472
-
if (last_task_used_math == current)
473
-
last_task_used_math = NULL;
474
-
#ifdef CONFIG_ALTIVEC
475
-
if (last_task_used_altivec == current)
476
-
last_task_used_altivec = NULL;
477
-
#endif /* CONFIG_ALTIVEC */
478
-
#ifdef CONFIG_SPE
479
-
if (last_task_used_spe == current)
480
-
last_task_used_spe = NULL;
481
-
#endif
482
-
#endif /* CONFIG_SMP */
461
+
discard_lazy_cpu_state();
483
462
484
463
#ifdef CONFIG_PPC64 /* for now */
485
464
if (current->thread.dabr) {
···
634
635
}
635
636
#endif
636
637
637
-
#ifndef CONFIG_SMP
638
-
if (last_task_used_math == current)
639
-
last_task_used_math = NULL;
640
-
#ifdef CONFIG_ALTIVEC
641
-
if (last_task_used_altivec == current)
642
-
last_task_used_altivec = NULL;
643
-
#endif
644
-
#ifdef CONFIG_SPE
645
-
if (last_task_used_spe == current)
646
-
last_task_used_spe = NULL;
647
-
#endif
648
-
#endif /* CONFIG_SMP */
638
+
discard_lazy_cpu_state();
649
639
memset(current->thread.fpr, 0, sizeof(current->thread.fpr));
650
640
current->thread.fpscr.val = 0;
651
641
#ifdef CONFIG_ALTIVEC
+1
-1
arch/powerpc/kernel/prom_init.c
+1
-1
arch/powerpc/kernel/prom_init.c
+2
-4
arch/powerpc/kernel/vdso.c
+2
-4
arch/powerpc/kernel/vdso.c
···
145
145
struct page *pg = virt_to_page(vdso32_kbase +
146
146
i*PAGE_SIZE);
147
147
struct page *upg = (vma && vma->vm_mm) ?
148
-
follow_page(vma->vm_mm, vma->vm_start +
149
-
i*PAGE_SIZE, 0)
148
+
follow_page(vma, vma->vm_start + i*PAGE_SIZE, 0)
150
149
: NULL;
151
150
dump_one_vdso_page(pg, upg);
152
151
}
···
156
157
struct page *pg = virt_to_page(vdso64_kbase +
157
158
i*PAGE_SIZE);
158
159
struct page *upg = (vma && vma->vm_mm) ?
159
-
follow_page(vma->vm_mm, vma->vm_start +
160
-
i*PAGE_SIZE, 0)
160
+
follow_page(vma, vma->vm_start + i*PAGE_SIZE, 0)
161
161
: NULL;
162
162
dump_one_vdso_page(pg, upg);
163
163
}
+1
-1
arch/ppc/kernel/ppc_ksyms.c
+1
-1
arch/ppc/kernel/ppc_ksyms.c
···
184
184
185
185
EXPORT_SYMBOL(flush_instruction_cache);
186
186
EXPORT_SYMBOL(giveup_fpu);
187
-
EXPORT_SYMBOL(flush_icache_range);
187
+
EXPORT_SYMBOL(__flush_icache_range);
188
188
EXPORT_SYMBOL(flush_dcache_range);
189
189
EXPORT_SYMBOL(flush_icache_user_range);
190
190
EXPORT_SYMBOL(flush_dcache_page);
+6
arch/ppc/kernel/process.c
+6
arch/ppc/kernel/process.c
···
417
417
418
418
void exit_thread(void)
419
419
{
420
+
preempt_disable();
420
421
if (last_task_used_math == current)
421
422
last_task_used_math = NULL;
422
423
if (last_task_used_altivec == current)
···
426
425
if (last_task_used_spe == current)
427
426
last_task_used_spe = NULL;
428
427
#endif
428
+
preempt_enable();
429
429
}
430
430
431
431
void flush_thread(void)
432
432
{
433
+
preempt_disable();
433
434
if (last_task_used_math == current)
434
435
last_task_used_math = NULL;
435
436
if (last_task_used_altivec == current)
···
440
437
if (last_task_used_spe == current)
441
438
last_task_used_spe = NULL;
442
439
#endif
440
+
preempt_enable();
443
441
}
444
442
445
443
void
···
539
535
regs->nip = nip;
540
536
regs->gpr[1] = sp;
541
537
regs->msr = MSR_USER;
538
+
preempt_disable();
542
539
if (last_task_used_math == current)
543
540
last_task_used_math = NULL;
544
541
if (last_task_used_altivec == current)
···
548
543
if (last_task_used_spe == current)
549
544
last_task_used_spe = NULL;
550
545
#endif
546
+
preempt_enable();
551
547
memset(current->thread.fpr, 0, sizeof(current->thread.fpr));
552
548
current->thread.fpscr.val = 0;
553
549
#ifdef CONFIG_ALTIVEC
+5
-5
arch/sparc/mm/generic.c
+5
-5
arch/sparc/mm/generic.c
···
32
32
if (end > PMD_SIZE)
33
33
end = PMD_SIZE;
34
34
do {
35
-
pte_t oldpage = *pte;
36
-
pte_clear(mm, address, pte);
37
-
set_pte(pte, mk_pte_io(offset, prot, space));
35
+
set_pte_at(mm, address, pte, mk_pte_io(offset, prot, space));
38
36
address += PAGE_SIZE;
39
37
offset += PAGE_SIZE;
40
38
pte++;
···
61
63
}
62
64
63
65
int io_remap_pfn_range(struct vm_area_struct *vma, unsigned long from,
64
-
unsigned long pfn, unsigned long size, pgprot_t prot)
66
+
unsigned long pfn, unsigned long size, pgprot_t prot)
65
67
{
66
68
int error = 0;
67
69
pgd_t * dir;
···
72
74
unsigned long offset = GET_PFN(pfn) << PAGE_SHIFT;
73
75
74
76
/* See comment in mm/memory.c remap_pfn_range */
75
-
vma->vm_flags |= VM_IO | VM_RESERVED | VM_UNPAGED;
77
+
vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP;
78
+
vma->vm_pgoff = (offset >> PAGE_SHIFT) |
79
+
((unsigned long)space << 28UL);
76
80
77
81
prot = __pgprot(pg_iobits);
78
82
offset -= from;
+15
-1
arch/sparc64/mm/generic.c
+15
-1
arch/sparc64/mm/generic.c
···
15
15
#include <asm/page.h>
16
16
#include <asm/tlbflush.h>
17
17
18
+
static inline pte_t mk_pte_io(unsigned long page, pgprot_t prot, int space)
19
+
{
20
+
pte_t pte;
21
+
pte_val(pte) = (((page) | pgprot_val(prot) | _PAGE_E) &
22
+
~(unsigned long)_PAGE_CACHE);
23
+
pte_val(pte) |= (((unsigned long)space) << 32);
24
+
return pte;
25
+
}
26
+
18
27
/* Remap IO memory, the same way as remap_pfn_range(), but use
19
28
* the obio memory space.
20
29
*
···
77
68
BUG_ON(!pte_none(*pte));
78
69
set_pte_at(mm, address, pte, entry);
79
70
address += PAGE_SIZE;
71
+
pte_val(entry) += PAGE_SIZE;
80
72
pte++;
81
73
} while (address < curend);
82
74
} while (address < end);
···
136
126
struct mm_struct *mm = vma->vm_mm;
137
127
int space = GET_IOSPACE(pfn);
138
128
unsigned long offset = GET_PFN(pfn) << PAGE_SHIFT;
129
+
unsigned long phys_base;
130
+
131
+
phys_base = offset | (((unsigned long) space) << 32UL);
139
132
140
133
/* See comment in mm/memory.c remap_pfn_range */
141
-
vma->vm_flags |= VM_IO | VM_RESERVED | VM_UNPAGED;
134
+
vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP;
135
+
vma->vm_pgoff = phys_base >> PAGE_SHIFT;
142
136
143
137
prot = __pgprot(pg_iobits);
144
138
offset -= from;
+7
drivers/atm/Kconfig
+7
drivers/atm/Kconfig
···
5
5
menu "ATM drivers"
6
6
depends on NETDEVICES && ATM
7
7
8
+
config ATM_DUMMY
9
+
tristate "Dummy ATM driver"
10
+
depends on ATM
11
+
help
12
+
Dummy ATM driver. Useful for proxy signalling, testing,
13
+
and development. If unsure, say N.
14
+
8
15
config ATM_TCP
9
16
tristate "ATM over TCP"
10
17
depends on INET && ATM
+1
drivers/atm/Makefile
+1
drivers/atm/Makefile
+168
drivers/atm/adummy.c
+168
drivers/atm/adummy.c
···
1
+
/*
2
+
* adummy.c: a dummy ATM driver
3
+
*/
4
+
5
+
#include <linux/config.h>
6
+
#include <linux/module.h>
7
+
#include <linux/version.h>
8
+
#include <linux/kernel.h>
9
+
#include <linux/skbuff.h>
10
+
#include <linux/pci.h>
11
+
#include <linux/errno.h>
12
+
#include <linux/types.h>
13
+
#include <linux/string.h>
14
+
#include <linux/delay.h>
15
+
#include <linux/init.h>
16
+
#include <linux/mm.h>
17
+
#include <linux/sched.h>
18
+
#include <linux/timer.h>
19
+
#include <linux/interrupt.h>
20
+
#include <asm/io.h>
21
+
#include <asm/byteorder.h>
22
+
#include <asm/uaccess.h>
23
+
24
+
#include <linux/atmdev.h>
25
+
#include <linux/atm.h>
26
+
#include <linux/sonet.h>
27
+
28
+
/* version definition */
29
+
30
+
#define DRV_VERSION "1.0"
31
+
32
+
#define DEV_LABEL "adummy"
33
+
34
+
#define ADUMMY_DEV(dev) ((struct adummy_dev *) (dev)->dev_data)
35
+
36
+
struct adummy_dev {
37
+
struct atm_dev *atm_dev;
38
+
39
+
struct list_head entry;
40
+
};
41
+
42
+
/* globals */
43
+
44
+
static LIST_HEAD(adummy_devs);
45
+
46
+
static int __init
47
+
adummy_start(struct atm_dev *dev)
48
+
{
49
+
dev->ci_range.vpi_bits = 4;
50
+
dev->ci_range.vci_bits = 12;
51
+
52
+
return 0;
53
+
}
54
+
55
+
static int
56
+
adummy_open(struct atm_vcc *vcc)
57
+
{
58
+
short vpi = vcc->vpi;
59
+
int vci = vcc->vci;
60
+
61
+
if (vci == ATM_VCI_UNSPEC || vpi == ATM_VPI_UNSPEC)
62
+
return 0;
63
+
64
+
set_bit(ATM_VF_ADDR, &vcc->flags);
65
+
set_bit(ATM_VF_READY, &vcc->flags);
66
+
67
+
return 0;
68
+
}
69
+
70
+
static void
71
+
adummy_close(struct atm_vcc *vcc)
72
+
{
73
+
clear_bit(ATM_VF_READY, &vcc->flags);
74
+
clear_bit(ATM_VF_ADDR, &vcc->flags);
75
+
}
76
+
77
+
static int
78
+
adummy_send(struct atm_vcc *vcc, struct sk_buff *skb)
79
+
{
80
+
if (vcc->pop)
81
+
vcc->pop(vcc, skb);
82
+
else
83
+
dev_kfree_skb_any(skb);
84
+
atomic_inc(&vcc->stats->tx);
85
+
86
+
return 0;
87
+
}
88
+
89
+
static int
90
+
adummy_proc_read(struct atm_dev *dev, loff_t *pos, char *page)
91
+
{
92
+
int left = *pos;
93
+
94
+
if (!left--)
95
+
return sprintf(page, "version %s\n", DRV_VERSION);
96
+
97
+
return 0;
98
+
}
99
+
100
+
static struct atmdev_ops adummy_ops =
101
+
{
102
+
.open = adummy_open,
103
+
.close = adummy_close,
104
+
.send = adummy_send,
105
+
.proc_read = adummy_proc_read,
106
+
.owner = THIS_MODULE
107
+
};
108
+
109
+
static int __init adummy_init(void)
110
+
{
111
+
struct atm_dev *atm_dev;
112
+
struct adummy_dev *adummy_dev;
113
+
int err = 0;
114
+
115
+
printk(KERN_ERR "adummy: version %s\n", DRV_VERSION);
116
+
117
+
adummy_dev = (struct adummy_dev *) kmalloc(sizeof(struct adummy_dev),
118
+
GFP_KERNEL);
119
+
if (!adummy_dev) {
120
+
printk(KERN_ERR DEV_LABEL ": kmalloc() failed\n");
121
+
err = -ENOMEM;
122
+
goto out;
123
+
}
124
+
memset(adummy_dev, 0, sizeof(struct adummy_dev));
125
+
126
+
atm_dev = atm_dev_register(DEV_LABEL, &adummy_ops, -1, 0);
127
+
if (!atm_dev) {
128
+
printk(KERN_ERR DEV_LABEL ": atm_dev_register() failed\n");
129
+
err = -ENODEV;
130
+
goto out_kfree;
131
+
}
132
+
133
+
adummy_dev->atm_dev = atm_dev;
134
+
atm_dev->dev_data = adummy_dev;
135
+
136
+
if (adummy_start(atm_dev)) {
137
+
printk(KERN_ERR DEV_LABEL ": adummy_start() failed\n");
138
+
err = -ENODEV;
139
+
goto out_unregister;
140
+
}
141
+
142
+
list_add(&adummy_dev->entry, &adummy_devs);
143
+
out:
144
+
return err;
145
+
146
+
out_unregister:
147
+
atm_dev_deregister(atm_dev);
148
+
out_kfree:
149
+
kfree(adummy_dev);
150
+
goto out;
151
+
}
152
+
153
+
static void __exit adummy_cleanup(void)
154
+
{
155
+
struct adummy_dev *adummy_dev, *next;
156
+
157
+
list_for_each_entry_safe(adummy_dev, next, &adummy_devs, entry) {
158
+
atm_dev_deregister(adummy_dev->atm_dev);
159
+
kfree(adummy_dev);
160
+
}
161
+
}
162
+
163
+
module_init(adummy_init);
164
+
module_exit(adummy_cleanup);
165
+
166
+
MODULE_AUTHOR("chas williams <chas@cmf.nrl.navy.mil>");
167
+
MODULE_DESCRIPTION("dummy ATM driver");
168
+
MODULE_LICENSE("GPL");
-54
drivers/atm/atmdev_init.c
-54
drivers/atm/atmdev_init.c
···
1
-
/* drivers/atm/atmdev_init.c - ATM device driver initialization */
2
-
3
-
/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
4
-
5
-
6
-
#include <linux/config.h>
7
-
#include <linux/init.h>
8
-
9
-
10
-
#ifdef CONFIG_ATM_ZATM
11
-
extern int zatm_detect(void);
12
-
#endif
13
-
#ifdef CONFIG_ATM_AMBASSADOR
14
-
extern int amb_detect(void);
15
-
#endif
16
-
#ifdef CONFIG_ATM_HORIZON
17
-
extern int hrz_detect(void);
18
-
#endif
19
-
#ifdef CONFIG_ATM_FORE200E
20
-
extern int fore200e_detect(void);
21
-
#endif
22
-
#ifdef CONFIG_ATM_LANAI
23
-
extern int lanai_detect(void);
24
-
#endif
25
-
26
-
27
-
/*
28
-
* For historical reasons, atmdev_init returns the number of devices found.
29
-
* Note that some detections may not go via atmdev_init (e.g. eni.c), so this
30
-
* number is meaningless.
31
-
*/
32
-
33
-
int __init atmdev_init(void)
34
-
{
35
-
int devs;
36
-
37
-
devs = 0;
38
-
#ifdef CONFIG_ATM_ZATM
39
-
devs += zatm_detect();
40
-
#endif
41
-
#ifdef CONFIG_ATM_AMBASSADOR
42
-
devs += amb_detect();
43
-
#endif
44
-
#ifdef CONFIG_ATM_HORIZON
45
-
devs += hrz_detect();
46
-
#endif
47
-
#ifdef CONFIG_ATM_FORE200E
48
-
devs += fore200e_detect();
49
-
#endif
50
-
#ifdef CONFIG_ATM_LANAI
51
-
devs += lanai_detect();
52
-
#endif
53
-
return devs;
54
-
}
+2
-18
drivers/atm/atmtcp.c
+2
-18
drivers/atm/atmtcp.c
···
246
246
{
247
247
struct atm_dev *atmtcp_dev;
248
248
struct atmtcp_dev_data *dev_data;
249
-
struct sock *s;
250
-
struct hlist_node *node;
251
-
struct atm_vcc *walk;
252
-
int i;
253
249
254
250
atmtcp_dev = (struct atm_dev *) vcc->dev_data;
255
251
dev_data = PRIV(atmtcp_dev);
···
253
257
if (dev_data->persist) return;
254
258
atmtcp_dev->dev_data = NULL;
255
259
kfree(dev_data);
256
-
shutdown_atm_dev(atmtcp_dev);
260
+
atm_dev_deregister(atmtcp_dev);
257
261
vcc->dev_data = NULL;
258
-
read_lock(&vcc_sklist_lock);
259
-
for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
260
-
struct hlist_head *head = &vcc_hash[i];
261
-
262
-
sk_for_each(s, node, head) {
263
-
walk = atm_sk(s);
264
-
if (walk->dev != atmtcp_dev)
265
-
continue;
266
-
wake_up(s->sk_sleep);
267
-
}
268
-
}
269
-
read_unlock(&vcc_sklist_lock);
270
262
module_put(THIS_MODULE);
271
263
}
272
264
···
434
450
if (PRIV(dev)->vcc) return 0;
435
451
kfree(dev_data);
436
452
atm_dev_put(dev);
437
-
shutdown_atm_dev(dev);
453
+
atm_dev_deregister(dev);
438
454
return 0;
439
455
}
440
456
+8
-94
drivers/atm/lanai.c
+8
-94
drivers/atm/lanai.c
···
39
39
* o lanai_change_qos() isn't written yet
40
40
*
41
41
* o There aren't any ioctl's yet -- I'd like to eventually support
42
-
* setting loopback and LED modes that way. (see lanai_ioctl)
42
+
* setting loopback and LED modes that way.
43
43
*
44
44
* o If the segmentation engine or DMA gets shut down we should restart
45
45
* card as per section 17.0i. (see lanai_reset)
···
305
305
* vci with their bit set
306
306
*/
307
307
static void vci_bitfield_iterate(struct lanai_dev *lanai,
308
-
/*const*/ unsigned long *lp,
308
+
const unsigned long *lp,
309
309
void (*func)(struct lanai_dev *,vci_t vci))
310
310
{
311
311
vci_t vci = find_first_bit(lp, NUM_VCI);
···
951
951
/* read a big-endian 4-byte value out of eeprom */
952
952
static inline u32 eeprom_be4(const struct lanai_dev *lanai, int address)
953
953
{
954
-
return be32_to_cpup((u32 *) (&lanai->eeprom[address]));
954
+
return be32_to_cpup((const u32 *) &lanai->eeprom[address]);
955
955
}
956
956
957
957
/* Checksum/validate EEPROM contents */
···
1160
1160
}
1161
1161
1162
1162
/* test if VCC is currently backlogged */
1163
-
static inline int vcc_is_backlogged(/*const*/ struct lanai_vcc *lvcc)
1163
+
static inline int vcc_is_backlogged(const struct lanai_vcc *lvcc)
1164
1164
{
1165
1165
return !skb_queue_empty(&lvcc->tx.backlog);
1166
1166
}
···
1395
1395
{
1396
1396
int size;
1397
1397
struct sk_buff *skb;
1398
-
/*const*/ u32 *x, *end = &lvcc->rx.buf.start[endptr * 4];
1398
+
const u32 *x;
1399
+
u32 *end = &lvcc->rx.buf.start[endptr * 4];
1399
1400
int n = ((unsigned long) end) - ((unsigned long) lvcc->rx.buf.ptr);
1400
1401
if (n < 0)
1401
1402
n += lanai_buf_size(&lvcc->rx.buf);
···
2112
2111
* shifted by that much as we compute
2113
2112
*
2114
2113
*/
2115
-
static int pcr_to_cbricg(/*const*/ struct atm_qos *qos)
2114
+
static int pcr_to_cbricg(const struct atm_qos *qos)
2116
2115
{
2117
2116
int rounddown = 0; /* 1 = Round PCR down, i.e. round ICG _up_ */
2118
2117
int x, icg, pcr = atm_pcr_goal(&qos->txtp);
···
2435
2434
return result;
2436
2435
}
2437
2436
2438
-
#if 0
2439
-
/* ioctl operations for card */
2440
-
/* NOTE: these are all DEBUGGING ONLY currently */
2441
-
static int lanai_ioctl(struct atm_dev *atmdev, unsigned int cmd, void __user *arg)
2442
-
{
2443
-
int result = 0;
2444
-
struct lanai_dev *lanai = (struct lanai_dev *) atmdev->dev_data;
2445
-
switch(cmd) {
2446
-
case 2106275:
2447
-
shutdown_atm_dev(atmdev);
2448
-
return 0;
2449
-
case 2200000: {
2450
-
unsigned long flags;
2451
-
spin_lock_irqsave(&lanai->servicelock, flags);
2452
-
run_service(lanai);
2453
-
spin_unlock_irqrestore(&lanai->servicelock, flags);
2454
-
return 0; }
2455
-
case 2200002:
2456
-
get_statistics(lanai);
2457
-
return 0;
2458
-
case 2200003: {
2459
-
unsigned int i;
2460
-
for (i = 0; i <= 0x5C ; i += 4) {
2461
-
if (i==0x48) /* Write-only butt reg */
2462
-
continue;
2463
-
printk(KERN_CRIT DEV_LABEL " 0x%02X: "
2464
-
"0x%08X\n", i,
2465
-
(unsigned int) readl(lanai->base + i));
2466
-
barrier(); mb();
2467
-
pcistatus_check(lanai, 0);
2468
-
barrier(); mb();
2469
-
}
2470
-
return 0; }
2471
-
case 2200004: {
2472
-
u8 b;
2473
-
u16 w;
2474
-
u32 dw;
2475
-
struct pci_dev *pci = lanai->pci;
2476
-
(void) pci_read_config_word(pci, PCI_VENDOR_ID, &w);
2477
-
DPRINTK("vendor = 0x%X\n", (unsigned int) w);
2478
-
(void) pci_read_config_word(pci, PCI_DEVICE_ID, &w);
2479
-
DPRINTK("device = 0x%X\n", (unsigned int) w);
2480
-
(void) pci_read_config_word(pci, PCI_COMMAND, &w);
2481
-
DPRINTK("command = 0x%X\n", (unsigned int) w);
2482
-
(void) pci_read_config_word(pci, PCI_STATUS, &w);
2483
-
DPRINTK("status = 0x%X\n", (unsigned int) w);
2484
-
(void) pci_read_config_dword(pci,
2485
-
PCI_CLASS_REVISION, &dw);
2486
-
DPRINTK("class/revision = 0x%X\n", (unsigned int) dw);
2487
-
(void) pci_read_config_byte(pci,
2488
-
PCI_CACHE_LINE_SIZE, &b);
2489
-
DPRINTK("cache line size = 0x%X\n", (unsigned int) b);
2490
-
(void) pci_read_config_byte(pci, PCI_LATENCY_TIMER, &b);
2491
-
DPRINTK("latency = %d (0x%X)\n",
2492
-
(int) b, (unsigned int) b);
2493
-
(void) pci_read_config_byte(pci, PCI_HEADER_TYPE, &b);
2494
-
DPRINTK("header type = 0x%X\n", (unsigned int) b);
2495
-
(void) pci_read_config_byte(pci, PCI_BIST, &b);
2496
-
DPRINTK("bist = 0x%X\n", (unsigned int) b);
2497
-
/* skipping a few here */
2498
-
(void) pci_read_config_byte(pci,
2499
-
PCI_INTERRUPT_LINE, &b);
2500
-
DPRINTK("pci_int_line = 0x%X\n", (unsigned int) b);
2501
-
(void) pci_read_config_byte(pci,
2502
-
PCI_INTERRUPT_PIN, &b);
2503
-
DPRINTK("pci_int_pin = 0x%X\n", (unsigned int) b);
2504
-
(void) pci_read_config_byte(pci, PCI_MIN_GNT, &b);
2505
-
DPRINTK("min_gnt = 0x%X\n", (unsigned int) b);
2506
-
(void) pci_read_config_byte(pci, PCI_MAX_LAT, &b);
2507
-
DPRINTK("max_lat = 0x%X\n", (unsigned int) b); }
2508
-
return 0;
2509
-
#ifdef USE_POWERDOWN
2510
-
case 2200005:
2511
-
DPRINTK("Coming out of powerdown\n");
2512
-
lanai->conf1 &= ~CONFIG1_POWERDOWN;
2513
-
conf1_write(lanai);
2514
-
return 0;
2515
-
#endif
2516
-
default:
2517
-
result = -ENOIOCTLCMD;
2518
-
}
2519
-
return result;
2520
-
}
2521
-
#else /* !0 */
2522
-
#define lanai_ioctl NULL
2523
-
#endif /* 0 */
2524
-
2525
2437
static int lanai_send(struct atm_vcc *atmvcc, struct sk_buff *skb)
2526
2438
{
2527
2439
struct lanai_vcc *lvcc = (struct lanai_vcc *) atmvcc->dev_data;
···
2592
2678
.dev_close = lanai_dev_close,
2593
2679
.open = lanai_open,
2594
2680
.close = lanai_close,
2595
-
.ioctl = lanai_ioctl,
2596
2681
.getsockopt = NULL,
2597
2682
.setsockopt = NULL,
2598
2683
.send = lanai_send,
···
2673
2760
* gone, so there isn't much to do
2674
2761
*/
2675
2762
DPRINTK("cleanup_module()\n");
2763
+
pci_unregister_driver(&lanai_driver);
2676
2764
}
2677
2765
2678
2766
module_init(lanai_module_init);
+1
-1
drivers/char/mem.c
+1
-1
drivers/char/mem.c
+2
-10
drivers/cpufreq/cpufreq.c
+2
-10
drivers/cpufreq/cpufreq.c
···
1113
1113
{
1114
1114
int retval = -EINVAL;
1115
1115
1116
-
/*
1117
-
* If we are already in context of hotplug thread, we dont need to
1118
-
* acquire the hotplug lock. Otherwise acquire cpucontrol to prevent
1119
-
* hotplug from removing this cpu that we are working on.
1120
-
*/
1121
-
if (!current_in_cpu_hotplug())
1122
-
lock_cpu_hotplug();
1123
-
1116
+
lock_cpu_hotplug();
1124
1117
dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1125
1118
target_freq, relation);
1126
1119
if (cpu_online(policy->cpu) && cpufreq_driver->target)
1127
1120
retval = cpufreq_driver->target(policy, target_freq, relation);
1128
1121
1129
-
if (!current_in_cpu_hotplug())
1130
-
unlock_cpu_hotplug();
1122
+
unlock_cpu_hotplug();
1131
1123
1132
1124
return retval;
1133
1125
}
+3
-1
drivers/md/md.c
+3
-1
drivers/md/md.c
···
1028
1028
mddev->size = le64_to_cpu(sb->size)/2;
1029
1029
mddev->events = le64_to_cpu(sb->events);
1030
1030
mddev->bitmap_offset = 0;
1031
-
mddev->default_bitmap_offset = 0;
1032
1031
mddev->default_bitmap_offset = 1024;
1033
1032
1034
1033
mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
···
2930
2931
mddev->max_disks = MD_SB_DISKS;
2931
2932
2932
2933
mddev->sb_dirty = 1;
2934
+
2935
+
mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
2936
+
mddev->bitmap_offset = 0;
2933
2937
2934
2938
/*
2935
2939
* Generate a 128 bit UUID
+4
-4
drivers/md/raid1.c
+4
-4
drivers/md/raid1.c
···
953
953
int mirror = 0;
954
954
mirror_info_t *p;
955
955
956
-
if (rdev->saved_raid_disk >= 0 &&
957
-
conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
958
-
mirror = rdev->saved_raid_disk;
959
956
for (mirror=0; mirror < mddev->raid_disks; mirror++)
960
957
if ( !(p=conf->mirrors+mirror)->rdev) {
961
958
···
969
972
p->head_position = 0;
970
973
rdev->raid_disk = mirror;
971
974
found = 1;
972
-
if (rdev->saved_raid_disk != mirror)
975
+
/* As all devices are equivalent, we don't need a full recovery
976
+
* if this was recently any drive of the array
977
+
*/
978
+
if (rdev->saved_raid_disk < 0)
973
979
conf->fullsync = 1;
974
980
rcu_assign_pointer(p->rdev, rdev);
975
981
break;
+5
-1
drivers/md/raid10.c
+5
-1
drivers/md/raid10.c
···
552
552
!test_bit(In_sync, &rdev->flags))
553
553
continue;
554
554
555
-
if (!atomic_read(&rdev->nr_pending)) {
555
+
/* This optimisation is debatable, and completely destroys
556
+
* sequential read speed for 'far copies' arrays. So only
557
+
* keep it for 'near' arrays, and review those later.
558
+
*/
559
+
if (conf->near_copies > 1 && !atomic_read(&rdev->nr_pending)) {
556
560
disk = ndisk;
557
561
slot = nslot;
558
562
break;
+2
drivers/md/raid5.c
+2
drivers/md/raid5.c
···
1704
1704
1705
1705
if (conf->seq_flush - conf->seq_write > 0) {
1706
1706
int seq = conf->seq_flush;
1707
+
spin_unlock_irq(&conf->device_lock);
1707
1708
bitmap_unplug(mddev->bitmap);
1709
+
spin_lock_irq(&conf->device_lock);
1708
1710
conf->seq_write = seq;
1709
1711
activate_bit_delay(conf);
1710
1712
}
+23
-4
drivers/md/raid6main.c
+23
-4
drivers/md/raid6main.c
···
1702
1702
int data_disks = raid_disks - 2;
1703
1703
sector_t max_sector = mddev->size << 1;
1704
1704
int sync_blocks;
1705
+
int still_degraded = 0;
1706
+
int i;
1705
1707
1706
1708
if (sector_nr >= max_sector) {
1707
1709
/* just being told to finish up .. nothing much to do */
···
1712
1710
if (mddev->curr_resync < max_sector) /* aborted */
1713
1711
bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
1714
1712
&sync_blocks, 1);
1715
-
else /* compelted sync */
1713
+
else /* completed sync */
1716
1714
conf->fullsync = 0;
1717
1715
bitmap_close_sync(mddev->bitmap);
1718
1716
···
1750
1748
*/
1751
1749
schedule_timeout_uninterruptible(1);
1752
1750
}
1753
-
bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, 0);
1751
+
/* Need to check if array will still be degraded after recovery/resync
1752
+
* We don't need to check the 'failed' flag as when that gets set,
1753
+
* recovery aborts.
1754
+
*/
1755
+
for (i=0; i<mddev->raid_disks; i++)
1756
+
if (conf->disks[i].rdev == NULL)
1757
+
still_degraded = 1;
1758
+
1759
+
bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, still_degraded);
1760
+
1754
1761
spin_lock(&sh->lock);
1755
1762
set_bit(STRIPE_SYNCING, &sh->state);
1756
1763
clear_bit(STRIPE_INSYNC, &sh->state);
···
1795
1784
1796
1785
if (conf->seq_flush - conf->seq_write > 0) {
1797
1786
int seq = conf->seq_flush;
1787
+
spin_unlock_irq(&conf->device_lock);
1798
1788
bitmap_unplug(mddev->bitmap);
1789
+
spin_lock_irq(&conf->device_lock);
1799
1790
conf->seq_write = seq;
1800
1791
activate_bit_delay(conf);
1801
1792
}
···
2158
2145
/* no point adding a device */
2159
2146
return 0;
2160
2147
/*
2161
-
* find the disk ...
2148
+
* find the disk ... but prefer rdev->saved_raid_disk
2149
+
* if possible.
2162
2150
*/
2163
-
for (disk=0; disk < mddev->raid_disks; disk++)
2151
+
if (rdev->saved_raid_disk >= 0 &&
2152
+
conf->disks[rdev->saved_raid_disk].rdev == NULL)
2153
+
disk = rdev->saved_raid_disk;
2154
+
else
2155
+
disk = 0;
2156
+
for ( ; disk < mddev->raid_disks; disk++)
2164
2157
if ((p=conf->disks + disk)->rdev == NULL) {
2165
2158
clear_bit(In_sync, &rdev->flags);
2166
2159
rdev->raid_disk = disk;
+1
-1
drivers/media/video/Kconfig
+1
-1
drivers/media/video/Kconfig
+10
-10
drivers/media/video/cx88/Kconfig
+10
-10
drivers/media/video/cx88/Kconfig
···
46
46
If you are unsure, choose Y.
47
47
48
48
config VIDEO_CX88_DVB_MT352
49
-
tristate "Zarlink MT352 DVB-T Support"
50
-
default m
49
+
bool "Zarlink MT352 DVB-T Support"
50
+
default y
51
51
depends on VIDEO_CX88_DVB && !VIDEO_CX88_DVB_ALL_FRONTENDS
52
52
select DVB_MT352
53
53
---help---
···
55
55
Connexant 2388x chip and the MT352 demodulator.
56
56
57
57
config VIDEO_CX88_DVB_OR51132
58
-
tristate "OR51132 ATSC Support"
59
-
default m
58
+
bool "OR51132 ATSC Support"
59
+
default y
60
60
depends on VIDEO_CX88_DVB && !VIDEO_CX88_DVB_ALL_FRONTENDS
61
61
select DVB_OR51132
62
62
---help---
···
64
64
Connexant 2388x chip and the OR51132 demodulator.
65
65
66
66
config VIDEO_CX88_DVB_CX22702
67
-
tristate "Conexant CX22702 DVB-T Support"
68
-
default m
67
+
bool "Conexant CX22702 DVB-T Support"
68
+
default y
69
69
depends on VIDEO_CX88_DVB && !VIDEO_CX88_DVB_ALL_FRONTENDS
70
70
select DVB_CX22702
71
71
---help---
···
73
73
Connexant 2388x chip and the CX22702 demodulator.
74
74
75
75
config VIDEO_CX88_DVB_LGDT330X
76
-
tristate "LG Electronics DT3302/DT3303 ATSC Support"
77
-
default m
76
+
bool "LG Electronics DT3302/DT3303 ATSC Support"
77
+
default y
78
78
depends on VIDEO_CX88_DVB && !VIDEO_CX88_DVB_ALL_FRONTENDS
79
79
select DVB_LGDT330X
80
80
---help---
···
82
82
Connexant 2388x chip and the LGDT3302/LGDT3303 demodulator.
83
83
84
84
config VIDEO_CX88_DVB_NXT200X
85
-
tristate "NXT2002/NXT2004 ATSC Support"
86
-
default m
85
+
bool "NXT2002/NXT2004 ATSC Support"
86
+
default y
87
87
depends on VIDEO_CX88_DVB && !VIDEO_CX88_DVB_ALL_FRONTENDS
88
88
select DVB_NXT200X
89
89
---help---
+9
-18
drivers/media/video/cx88/Makefile
+9
-18
drivers/media/video/cx88/Makefile
···
9
9
EXTRA_CFLAGS += -I$(src)/..
10
10
EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core
11
11
EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/frontends
12
-
ifneq ($(CONFIG_VIDEO_BUF_DVB),n)
13
-
EXTRA_CFLAGS += -DHAVE_VIDEO_BUF_DVB=1
14
-
endif
15
-
ifneq ($(CONFIG_DVB_CX22702),n)
16
-
EXTRA_CFLAGS += -DHAVE_CX22702=1
17
-
endif
18
-
ifneq ($(CONFIG_DVB_OR51132),n)
19
-
EXTRA_CFLAGS += -DHAVE_OR51132=1
20
-
endif
21
-
ifneq ($(CONFIG_DVB_LGDT330X),n)
22
-
EXTRA_CFLAGS += -DHAVE_LGDT330X=1
23
-
endif
24
-
ifneq ($(CONFIG_DVB_MT352),n)
25
-
EXTRA_CFLAGS += -DHAVE_MT352=1
26
-
endif
27
-
ifneq ($(CONFIG_DVB_NXT200X),n)
28
-
EXTRA_CFLAGS += -DHAVE_NXT200X=1
29
-
endif
12
+
13
+
extra-cflags-$(CONFIG_VIDEO_BUF_DVB) += -DHAVE_VIDEO_BUF_DVB=1
14
+
extra-cflags-$(CONFIG_DVB_CX22702) += -DHAVE_CX22702=1
15
+
extra-cflags-$(CONFIG_DVB_OR51132) += -DHAVE_OR51132=1
16
+
extra-cflags-$(CONFIG_DVB_LGDT330X) += -DHAVE_LGDT330X=1
17
+
extra-cflags-$(CONFIG_DVB_MT352) += -DHAVE_MT352=1
18
+
extra-cflags-$(CONFIG_DVB_NXT200X) += -DHAVE_NXT200X=1
19
+
20
+
EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m)
+6
-6
drivers/media/video/saa7134/Kconfig
+6
-6
drivers/media/video/saa7134/Kconfig
···
42
42
If you are unsure, choose Y.
43
43
44
44
config VIDEO_SAA7134_DVB_MT352
45
-
tristate "Zarlink MT352 DVB-T Support"
46
-
default m
45
+
bool "Zarlink MT352 DVB-T Support"
46
+
default y
47
47
depends on VIDEO_SAA7134_DVB && !VIDEO_SAA7134_DVB_ALL_FRONTENDS
48
48
select DVB_MT352
49
49
---help---
···
51
51
Philips saa7134 chip and the MT352 demodulator.
52
52
53
53
config VIDEO_SAA7134_DVB_TDA1004X
54
-
tristate "Phillips TDA10045H/TDA10046H DVB-T Support"
55
-
default m
54
+
bool "Phillips TDA10045H/TDA10046H DVB-T Support"
55
+
default y
56
56
depends on VIDEO_SAA7134_DVB && !VIDEO_SAA7134_DVB_ALL_FRONTENDS
57
57
select DVB_TDA1004X
58
58
---help---
···
60
60
Philips saa7134 chip and the TDA10045H/TDA10046H demodulator.
61
61
62
62
config VIDEO_SAA7134_DVB_NXT200X
63
-
tristate "NXT2002/NXT2004 ATSC Support"
64
-
default m
63
+
bool "NXT2002/NXT2004 ATSC Support"
64
+
default y
65
65
depends on VIDEO_SAA7134_DVB && !VIDEO_SAA7134_DVB_ALL_FRONTENDS
66
66
select DVB_NXT200X
67
67
---help---
+7
-12
drivers/media/video/saa7134/Makefile
+7
-12
drivers/media/video/saa7134/Makefile
···
11
11
EXTRA_CFLAGS += -I$(src)/..
12
12
EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core
13
13
EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/frontends
14
-
ifneq ($(CONFIG_VIDEO_BUF_DVB),n)
15
-
EXTRA_CFLAGS += -DHAVE_VIDEO_BUF_DVB=1
16
-
endif
17
-
ifneq ($(CONFIG_DVB_MT352),n)
18
-
EXTRA_CFLAGS += -DHAVE_MT352=1
19
-
endif
20
-
ifneq ($(CONFIG_DVB_TDA1004X),n)
21
-
EXTRA_CFLAGS += -DHAVE_TDA1004X=1
22
-
endif
23
-
ifneq ($(CONFIG_DVB_NXT200X),n)
24
-
EXTRA_CFLAGS += -DHAVE_NXT200X=1
25
-
endif
14
+
15
+
extra-cflags-$(CONFIG_VIDEO_BUF_DVB) += -DHAVE_VIDEO_BUF_DVB=1
16
+
extra-cflags-$(CONFIG_DVB_MT352) += -DHAVE_MT352=1
17
+
extra-cflags-$(CONFIG_DVB_TDA1004X) += -DHAVE_TDA1004X=1
18
+
extra-cflags-$(CONFIG_DVB_NXT200X) += -DHAVE_NXT200X=1
19
+
20
+
EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m)
+4
-2
drivers/message/fusion/mptbase.c
+4
-2
drivers/message/fusion/mptbase.c
···
91
91
* Public data...
92
92
*/
93
93
int mpt_lan_index = -1;
94
-
static int mpt_stm_index = -1;
94
+
int mpt_stm_index = -1;
95
95
96
-
static struct proc_dir_entry *mpt_proc_root_dir;
96
+
struct proc_dir_entry *mpt_proc_root_dir;
97
97
98
98
#define WHOINIT_UNKNOWN 0xAA
99
99
···
6271
6271
EXPORT_SYMBOL(mpt_suspend);
6272
6272
#endif
6273
6273
EXPORT_SYMBOL(ioc_list);
6274
+
EXPORT_SYMBOL(mpt_proc_root_dir);
6274
6275
EXPORT_SYMBOL(mpt_register);
6275
6276
EXPORT_SYMBOL(mpt_deregister);
6276
6277
EXPORT_SYMBOL(mpt_event_register);
···
6289
6288
EXPORT_SYMBOL(mpt_GetIocState);
6290
6289
EXPORT_SYMBOL(mpt_print_ioc_summary);
6291
6290
EXPORT_SYMBOL(mpt_lan_index);
6291
+
EXPORT_SYMBOL(mpt_stm_index);
6292
6292
EXPORT_SYMBOL(mpt_HardResetHandler);
6293
6293
EXPORT_SYMBOL(mpt_config);
6294
6294
EXPORT_SYMBOL(mpt_toolbox);
+2
drivers/message/fusion/mptbase.h
+2
drivers/message/fusion/mptbase.h
···
1006
1006
* Public data decl's...
1007
1007
*/
1008
1008
extern struct list_head ioc_list;
1009
+
extern struct proc_dir_entry *mpt_proc_root_dir;
1009
1010
1010
1011
extern int mpt_lan_index; /* needed by mptlan.c */
1012
+
extern int mpt_stm_index; /* needed by mptstm.c */
1011
1013
1012
1014
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1013
1015
#endif /* } __KERNEL__ */
+1
-1
drivers/mmc/mmc.c
+1
-1
drivers/mmc/mmc.c
+4
-6
drivers/mtd/chips/cfi_cmdset_0001.c
+4
-6
drivers/mtd/chips/cfi_cmdset_0001.c
···
4
4
*
5
5
* (C) 2000 Red Hat. GPL'd
6
6
*
7
-
* $Id: cfi_cmdset_0001.c,v 1.185 2005/11/07 11:14:22 gleixner Exp $
7
+
* $Id: cfi_cmdset_0001.c,v 1.186 2005/11/23 22:07:52 nico Exp $
8
8
*
9
9
*
10
10
* 10/10/2000 Nicolas Pitre <nico@cam.org>
···
644
644
*
645
645
* - contension arbitration is handled in the owner's context.
646
646
*
647
-
* The 'shared' struct can be read when its lock is taken.
648
-
* However any writes to it can only be made when the current
649
-
* owner's lock is also held.
647
+
* The 'shared' struct can be read and/or written only when
648
+
* its lock is taken.
650
649
*/
651
650
struct flchip_shared *shared = chip->priv;
652
651
struct flchip *contender;
···
674
675
}
675
676
timeo = jiffies + HZ;
676
677
spin_lock(&shared->lock);
678
+
spin_unlock(contender->mutex);
677
679
}
678
680
679
681
/* We now own it */
680
682
shared->writing = chip;
681
683
if (mode == FL_ERASING)
682
684
shared->erasing = chip;
683
-
if (contender && contender != chip)
684
-
spin_unlock(contender->mutex);
685
685
spin_unlock(&shared->lock);
686
686
}
687
687
+4
-4
drivers/mtd/chips/cfi_probe.c
+4
-4
drivers/mtd/chips/cfi_probe.c
···
1
1
/*
2
2
Common Flash Interface probe code.
3
3
(C) 2000 Red Hat. GPL'd.
4
-
$Id: cfi_probe.c,v 1.84 2005/11/07 11:14:23 gleixner Exp $
4
+
$Id: cfi_probe.c,v 1.86 2005/11/29 14:48:31 gleixner Exp $
5
5
*/
6
6
7
7
#include <linux/config.h>
···
230
230
cfi_send_gen_cmd(0xaa, 0x555, base, map, cfi, cfi->device_type, NULL);
231
231
cfi_send_gen_cmd(0x55, 0x2aa, base, map, cfi, cfi->device_type, NULL);
232
232
cfi_send_gen_cmd(0x90, 0x555, base, map, cfi, cfi->device_type, NULL);
233
-
cfi->mfr = cfi_read_query(map, base);
234
-
cfi->id = cfi_read_query(map, base + ofs_factor);
233
+
cfi->mfr = cfi_read_query16(map, base);
234
+
cfi->id = cfi_read_query16(map, base + ofs_factor);
235
235
236
236
/* Put it back into Read Mode */
237
237
cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
···
426
426
.module = THIS_MODULE
427
427
};
428
428
429
-
int __init cfi_probe_init(void)
429
+
static int __init cfi_probe_init(void)
430
430
{
431
431
register_mtd_chip_driver(&cfi_chipdrv);
432
432
return 0;
+66
-57
drivers/mtd/chips/sharp.c
+66
-57
drivers/mtd/chips/sharp.c
···
4
4
* Copyright 2000,2001 David A. Schleef <ds@schleef.org>
5
5
* 2000,2001 Lineo, Inc.
6
6
*
7
-
* $Id: sharp.c,v 1.16 2005/11/07 11:14:23 gleixner Exp $
7
+
* $Id: sharp.c,v 1.17 2005/11/29 14:28:28 gleixner Exp $
8
8
*
9
9
* Devices supported:
10
10
* LH28F016SCT Symmetrical block flash memory, 2Mx8
···
160
160
return mtd;
161
161
}
162
162
163
+
static inline void sharp_send_cmd(struct map_info *map, unsigned long cmd, unsigned long adr)
164
+
{
165
+
map_word map_cmd;
166
+
map_cmd.x[0] = cmd;
167
+
map_write(map, map_cmd, adr);
168
+
}
169
+
163
170
static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd)
164
171
{
165
-
unsigned long tmp;
172
+
map_word tmp, read0, read4;
166
173
unsigned long base = 0;
167
-
u32 read0, read4;
168
174
int width = 4;
169
175
170
-
tmp = map_read32(map, base+0);
176
+
tmp = map_read(map, base+0);
171
177
172
-
map_write32(map, CMD_READ_ID, base+0);
178
+
sharp_send_cmd(map, CMD_READ_ID, base+0);
173
179
174
-
read0=map_read32(map, base+0);
175
-
read4=map_read32(map, base+4);
176
-
if(read0 == 0x89898989){
180
+
read0 = map_read(map, base+0);
181
+
read4 = map_read(map, base+4);
182
+
if(read0.x[0] == 0x89898989){
177
183
printk("Looks like sharp flash\n");
178
-
switch(read4){
184
+
switch(read4.x[0]){
179
185
case 0xaaaaaaaa:
180
186
case 0xa0a0a0a0:
181
187
/* aa - LH28F016SCT-L95 2Mx8, 32 64k blocks*/
···
203
197
return width;
204
198
#endif
205
199
default:
206
-
printk("Sort-of looks like sharp flash, 0x%08x 0x%08x\n",
207
-
read0,read4);
200
+
printk("Sort-of looks like sharp flash, 0x%08lx 0x%08lx\n",
201
+
read0.x[0], read4.x[0]);
208
202
}
209
-
}else if((map_read32(map, base+0) == CMD_READ_ID)){
203
+
}else if((map_read(map, base+0).x[0] == CMD_READ_ID)){
210
204
/* RAM, probably */
211
205
printk("Looks like RAM\n");
212
-
map_write32(map, tmp, base+0);
206
+
map_write(map, tmp, base+0);
213
207
}else{
214
-
printk("Doesn't look like sharp flash, 0x%08x 0x%08x\n",
215
-
read0,read4);
208
+
printk("Doesn't look like sharp flash, 0x%08lx 0x%08lx\n",
209
+
read0.x[0], read4.x[0]);
216
210
}
217
211
218
212
return 0;
···
221
215
/* This function returns with the chip->mutex lock held. */
222
216
static int sharp_wait(struct map_info *map, struct flchip *chip)
223
217
{
224
-
int status, i;
218
+
int i;
219
+
map_word status;
225
220
unsigned long timeo = jiffies + HZ;
226
221
DECLARE_WAITQUEUE(wait, current);
227
222
int adr = 0;
···
232
225
233
226
switch(chip->state){
234
227
case FL_READY:
235
-
map_write32(map,CMD_READ_STATUS,adr);
228
+
sharp_send_cmd(map, CMD_READ_STATUS, adr);
236
229
chip->state = FL_STATUS;
237
230
case FL_STATUS:
238
231
for(i=0;i<100;i++){
239
-
status = map_read32(map,adr);
240
-
if((status & SR_READY)==SR_READY)
232
+
status = map_read(map, adr);
233
+
if((status.x[0] & SR_READY)==SR_READY)
241
234
break;
242
235
udelay(1);
243
236
}
···
261
254
goto retry;
262
255
}
263
256
264
-
map_write32(map,CMD_RESET, adr);
257
+
sharp_send_cmd(map, CMD_RESET, adr);
265
258
266
259
chip->state = FL_READY;
267
260
···
358
351
int timeo;
359
352
int try;
360
353
int i;
361
-
int status = 0;
354
+
map_word data, status;
362
355
356
+
status.x[0] = 0;
363
357
ret = sharp_wait(map,chip);
364
358
365
359
for(try=0;try<10;try++){
366
-
map_write32(map,CMD_BYTE_WRITE,adr);
360
+
sharp_send_cmd(map, CMD_BYTE_WRITE, adr);
367
361
/* cpu_to_le32 -> hack to fix the writel be->le conversion */
368
-
map_write32(map,cpu_to_le32(datum),adr);
362
+
data.x[0] = cpu_to_le32(datum);
363
+
map_write(map, data, adr);
369
364
370
365
chip->state = FL_WRITING;
371
366
372
367
timeo = jiffies + (HZ/2);
373
368
374
-
map_write32(map,CMD_READ_STATUS,adr);
369
+
sharp_send_cmd(map, CMD_READ_STATUS, adr);
375
370
for(i=0;i<100;i++){
376
-
status = map_read32(map,adr);
377
-
if((status & SR_READY)==SR_READY)
371
+
status = map_read(map, adr);
372
+
if((status.x[0] & SR_READY) == SR_READY)
378
373
break;
379
374
}
380
375
if(i==100){
381
376
printk("sharp: timed out writing\n");
382
377
}
383
378
384
-
if(!(status&SR_ERRORS))
379
+
if(!(status.x[0] & SR_ERRORS))
385
380
break;
386
381
387
-
printk("sharp: error writing byte at addr=%08lx status=%08x\n",adr,status);
382
+
printk("sharp: error writing byte at addr=%08lx status=%08lx\n", adr, status.x[0]);
388
383
389
-
map_write32(map,CMD_CLEAR_STATUS,adr);
384
+
sharp_send_cmd(map, CMD_CLEAR_STATUS, adr);
390
385
}
391
-
map_write32(map,CMD_RESET,adr);
386
+
sharp_send_cmd(map, CMD_RESET, adr);
392
387
chip->state = FL_READY;
393
388
394
389
wake_up(&chip->wq);
···
443
434
{
444
435
int ret;
445
436
unsigned long timeo;
446
-
int status;
437
+
map_word status;
447
438
DECLARE_WAITQUEUE(wait, current);
448
439
449
-
map_write32(map,CMD_READ_STATUS,adr);
450
-
status = map_read32(map,adr);
440
+
sharp_send_cmd(map, CMD_READ_STATUS, adr);
441
+
status = map_read(map, adr);
451
442
452
443
timeo = jiffies + HZ;
453
444
454
445
while(time_before(jiffies, timeo)){
455
-
map_write32(map,CMD_READ_STATUS,adr);
456
-
status = map_read32(map,adr);
457
-
if((status & SR_READY)==SR_READY){
446
+
sharp_send_cmd(map, CMD_READ_STATUS, adr);
447
+
status = map_read(map, adr);
448
+
if((status.x[0] & SR_READY)==SR_READY){
458
449
ret = 0;
459
450
goto out;
460
451
}
···
485
476
{
486
477
int ret;
487
478
//int timeo;
488
-
int status;
479
+
map_word status;
489
480
//int i;
490
481
491
482
//printk("sharp_erase_oneblock()\n");
···
495
486
sharp_unlock_oneblock(map,chip,adr);
496
487
#endif
497
488
498
-
map_write32(map,CMD_BLOCK_ERASE_1,adr);
499
-
map_write32(map,CMD_BLOCK_ERASE_2,adr);
489
+
sharp_send_cmd(map, CMD_BLOCK_ERASE_1, adr);
490
+
sharp_send_cmd(map, CMD_BLOCK_ERASE_2, adr);
500
491
501
492
chip->state = FL_ERASING;
502
493
503
494
ret = sharp_do_wait_for_ready(map,chip,adr);
504
495
if(ret<0)return ret;
505
496
506
-
map_write32(map,CMD_READ_STATUS,adr);
507
-
status = map_read32(map,adr);
497
+
sharp_send_cmd(map, CMD_READ_STATUS, adr);
498
+
status = map_read(map, adr);
508
499
509
-
if(!(status&SR_ERRORS)){
510
-
map_write32(map,CMD_RESET,adr);
500
+
if(!(status.x[0] & SR_ERRORS)){
501
+
sharp_send_cmd(map, CMD_RESET, adr);
511
502
chip->state = FL_READY;
512
503
//spin_unlock_bh(chip->mutex);
513
504
return 0;
514
505
}
515
506
516
-
printk("sharp: error erasing block at addr=%08lx status=%08x\n",adr,status);
517
-
map_write32(map,CMD_CLEAR_STATUS,adr);
507
+
printk("sharp: error erasing block at addr=%08lx status=%08lx\n", adr, status.x[0]);
508
+
sharp_send_cmd(map, CMD_CLEAR_STATUS, adr);
518
509
519
510
//spin_unlock_bh(chip->mutex);
520
511
···
526
517
unsigned long adr)
527
518
{
528
519
int i;
529
-
int status;
520
+
map_word status;
530
521
531
-
map_write32(map,CMD_CLEAR_BLOCK_LOCKS_1,adr);
532
-
map_write32(map,CMD_CLEAR_BLOCK_LOCKS_2,adr);
522
+
sharp_send_cmd(map, CMD_CLEAR_BLOCK_LOCKS_1, adr);
523
+
sharp_send_cmd(map, CMD_CLEAR_BLOCK_LOCKS_2, adr);
533
524
534
525
udelay(100);
535
526
536
-
status = map_read32(map,adr);
537
-
printk("status=%08x\n",status);
527
+
status = map_read(map, adr);
528
+
printk("status=%08lx\n", status.x[0]);
538
529
539
530
for(i=0;i<1000;i++){
540
-
//map_write32(map,CMD_READ_STATUS,adr);
541
-
status = map_read32(map,adr);
542
-
if((status & SR_READY)==SR_READY)
531
+
//sharp_send_cmd(map, CMD_READ_STATUS, adr);
532
+
status = map_read(map, adr);
533
+
if((status.x[0] & SR_READY) == SR_READY)
543
534
break;
544
535
udelay(100);
545
536
}
···
547
538
printk("sharp: timed out unlocking block\n");
548
539
}
549
540
550
-
if(!(status&SR_ERRORS)){
551
-
map_write32(map,CMD_RESET,adr);
541
+
if(!(status.x[0] & SR_ERRORS)){
542
+
sharp_send_cmd(map, CMD_RESET, adr);
552
543
chip->state = FL_READY;
553
544
return;
554
545
}
555
546
556
-
printk("sharp: error unlocking block at addr=%08lx status=%08x\n",adr,status);
557
-
map_write32(map,CMD_CLEAR_STATUS,adr);
547
+
printk("sharp: error unlocking block at addr=%08lx status=%08lx\n", adr, status.x[0]);
548
+
sharp_send_cmd(map, CMD_CLEAR_STATUS, adr);
558
549
}
559
550
#endif
560
551
+3
-3
drivers/mtd/devices/block2mtd.c
+3
-3
drivers/mtd/devices/block2mtd.c
···
1
1
/*
2
-
* $Id: block2mtd.c,v 1.29 2005/11/07 11:14:24 gleixner Exp $
2
+
* $Id: block2mtd.c,v 1.30 2005/11/29 14:48:32 gleixner Exp $
3
3
*
4
4
* block2mtd.c - create an mtd from a block device
5
5
*
···
19
19
#include <linux/mtd/mtd.h>
20
20
#include <linux/buffer_head.h>
21
21
22
-
#define VERSION "$Revision: 1.29 $"
22
+
#define VERSION "$Revision: 1.30 $"
23
23
24
24
25
25
#define ERROR(fmt, args...) printk(KERN_ERR "block2mtd: " fmt "\n" , ## args)
···
40
40
41
41
42
42
#define PAGE_READAHEAD 64
43
-
void cache_readahead(struct address_space *mapping, int index)
43
+
static void cache_readahead(struct address_space *mapping, int index)
44
44
{
45
45
filler_t *filler = (filler_t*)mapping->a_ops->readpage;
46
46
int i, pagei;
+3
-3
drivers/mtd/devices/ms02-nv.c
+3
-3
drivers/mtd/devices/ms02-nv.c
···
6
6
* as published by the Free Software Foundation; either version
7
7
* 2 of the License, or (at your option) any later version.
8
8
*
9
-
* $Id: ms02-nv.c,v 1.10 2005/06/20 12:24:41 macro Exp $
9
+
* $Id: ms02-nv.c,v 1.11 2005/11/14 13:41:47 macro Exp $
10
10
*/
11
11
12
12
#include <linux/init.h>
···
293
293
294
294
switch (mips_machtype) {
295
295
case MACH_DS5000_200:
296
-
csr = (volatile u32 *)KN02_CSR_BASE;
296
+
csr = (volatile u32 *)CKSEG1ADDR(KN02_SLOT_BASE + KN02_CSR);
297
297
if (*csr & KN02_CSR_BNK32M)
298
298
stride = 2;
299
299
break;
300
300
case MACH_DS5000_2X0:
301
301
case MACH_DS5900:
302
-
csr = (volatile u32 *)KN03_MCR_BASE;
302
+
csr = (volatile u32 *)CKSEG1ADDR(KN03_SLOT_BASE + IOASIC_MCR);
303
303
if (*csr & KN03_MCR_BNK32M)
304
304
stride = 2;
305
305
break;
+3
-3
drivers/mtd/ftl.c
+3
-3
drivers/mtd/ftl.c
···
1
1
/* This version ported to the Linux-MTD system by dwmw2@infradead.org
2
-
* $Id: ftl.c,v 1.58 2005/11/07 11:14:19 gleixner Exp $
2
+
* $Id: ftl.c,v 1.59 2005/11/29 14:48:31 gleixner Exp $
3
3
*
4
4
* Fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
5
5
* - fixes some leaks on failure in build_maps and ftl_notify_add, cleanups
···
1084
1084
.owner = THIS_MODULE,
1085
1085
};
1086
1086
1087
-
int init_ftl(void)
1087
+
static int init_ftl(void)
1088
1088
{
1089
-
DEBUG(0, "$Id: ftl.c,v 1.58 2005/11/07 11:14:19 gleixner Exp $\n");
1089
+
DEBUG(0, "$Id: ftl.c,v 1.59 2005/11/29 14:48:31 gleixner Exp $\n");
1090
1090
1091
1091
return register_mtd_blktrans(&ftl_tr);
1092
1092
}
-6
drivers/mtd/maps/Kconfig
-6
drivers/mtd/maps/Kconfig
···
538
538
This enables access to the flash chips on the Interface MPC-1211(CTP/PCI/MPC-SH02).
539
539
If you have such a board, say 'Y'.
540
540
541
-
config MTD_PQ2FADS
542
-
tristate "JEDEC flash SIMM mapped on PQ2FADS and 8272ADS boards"
543
-
depends on (ADS8272 || PQ2FADS) && MTD_PARTITIONS && MTD_JEDECPROBE && MTD_PHYSMAP && MTD_CFI_GEOMETRY && MTD_CFI_INTELEXT
544
-
help
545
-
This enables access to flash SIMM on PQ2FADS-like boards
546
-
547
541
config MTD_OMAP_NOR
548
542
tristate "TI OMAP board mappings"
549
543
depends on MTD_CFI && ARCH_OMAP
-1
drivers/mtd/maps/Makefile
-1
drivers/mtd/maps/Makefile
+66
-12
drivers/mtd/maps/ixp4xx.c
+66
-12
drivers/mtd/maps/ixp4xx.c
···
1
1
/*
2
-
* $Id: ixp4xx.c,v 1.12 2005/11/07 11:14:27 gleixner Exp $
2
+
* $Id: ixp4xx.c,v 1.13 2005/11/16 16:23:21 dvrabel Exp $
3
3
*
4
4
* drivers/mtd/maps/ixp4xx.c
5
5
*
···
34
34
35
35
#include <linux/reboot.h>
36
36
37
+
/*
38
+
* Read/write a 16 bit word from flash address 'addr'.
39
+
*
40
+
* When the cpu is in little-endian mode it swizzles the address lines
41
+
* ('address coherency') so we need to undo the swizzling to ensure commands
42
+
* and the like end up on the correct flash address.
43
+
*
44
+
* To further complicate matters, due to the way the expansion bus controller
45
+
* handles 32 bit reads, the byte stream ABCD is stored on the flash as:
46
+
* D15 D0
47
+
* +---+---+
48
+
* | A | B | 0
49
+
* +---+---+
50
+
* | C | D | 2
51
+
* +---+---+
52
+
* This means that on LE systems each 16 bit word must be swapped. Note that
53
+
* this requires CONFIG_MTD_CFI_BE_BYTE_SWAP to be enabled to 'unswap' the CFI
54
+
* data and other flash commands which are always in D7-D0.
55
+
*/
37
56
#ifndef __ARMEB__
57
+
#ifndef CONFIG_MTD_CFI_BE_BYTE_SWAP
58
+
# error CONFIG_MTD_CFI_BE_BYTE_SWAP required
59
+
#endif
60
+
61
+
static inline u16 flash_read16(void __iomem *addr)
62
+
{
63
+
return be16_to_cpu(__raw_readw((void __iomem *)((unsigned long)addr ^ 0x2)));
64
+
}
65
+
66
+
static inline void flash_write16(u16 d, void __iomem *addr)
67
+
{
68
+
__raw_writew(cpu_to_be16(d), (void __iomem *)((unsigned long)addr ^ 0x2));
69
+
}
70
+
38
71
#define BYTE0(h) ((h) & 0xFF)
39
72
#define BYTE1(h) (((h) >> 8) & 0xFF)
73
+
40
74
#else
75
+
76
+
static inline u16 flash_read16(const void __iomem *addr)
77
+
{
78
+
return __raw_readw(addr);
79
+
}
80
+
81
+
static inline void flash_write16(u16 d, void __iomem *addr)
82
+
{
83
+
__raw_writew(d, addr);
84
+
}
85
+
41
86
#define BYTE0(h) (((h) >> 8) & 0xFF)
42
87
#define BYTE1(h) ((h) & 0xFF)
43
88
#endif
···
90
45
static map_word ixp4xx_read16(struct map_info *map, unsigned long ofs)
91
46
{
92
47
map_word val;
93
-
val.x[0] = le16_to_cpu(readw(map->virt + ofs));
48
+
val.x[0] = flash_read16(map->virt + ofs);
94
49
return val;
95
50
}
96
51
···
102
57
static void ixp4xx_copy_from(struct map_info *map, void *to,
103
58
unsigned long from, ssize_t len)
104
59
{
105
-
int i;
106
60
u8 *dest = (u8 *) to;
107
61
void __iomem *src = map->virt + from;
108
-
u16 data;
109
62
110
-
for (i = 0; i < (len / 2); i++) {
111
-
data = le16_to_cpu(readw(src + 2*i));
112
-
dest[i * 2] = BYTE0(data);
113
-
dest[i * 2 + 1] = BYTE1(data);
63
+
if (len <= 0)
64
+
return;
65
+
66
+
if (from & 1) {
67
+
*dest++ = BYTE1(flash_read16(src));
68
+
src++;
69
+
--len;
114
70
}
115
71
116
-
if (len & 1)
117
-
dest[len - 1] = BYTE0(le16_to_cpu(readw(src + 2*i)));
72
+
while (len >= 2) {
73
+
u16 data = flash_read16(src);
74
+
*dest++ = BYTE0(data);
75
+
*dest++ = BYTE1(data);
76
+
src += 2;
77
+
len -= 2;
78
+
}
79
+
80
+
if (len > 0)
81
+
*dest++ = BYTE0(flash_read16(src));
118
82
}
119
83
120
84
/*
···
133
79
static void ixp4xx_probe_write16(struct map_info *map, map_word d, unsigned long adr)
134
80
{
135
81
if (!(adr & 1))
136
-
writew(cpu_to_le16(d.x[0]), map->virt + adr);
82
+
flash_write16(d.x[0], map->virt + adr);
137
83
}
138
84
139
85
/*
···
141
87
*/
142
88
static void ixp4xx_write16(struct map_info *map, map_word d, unsigned long adr)
143
89
{
144
-
writew(cpu_to_le16(d.x[0]), map->virt + adr);
90
+
flash_write16(d.x[0], map->virt + adr);
145
91
}
146
92
147
93
struct ixp4xx_flash_info {
+2
-2
drivers/mtd/maps/nettel.c
+2
-2
drivers/mtd/maps/nettel.c
···
6
6
* (C) Copyright 2000-2001, Greg Ungerer (gerg@snapgear.com)
7
7
* (C) Copyright 2001-2002, SnapGear (www.snapgear.com)
8
8
*
9
-
* $Id: nettel.c,v 1.11 2005/11/07 11:14:27 gleixner Exp $
9
+
* $Id: nettel.c,v 1.12 2005/11/29 14:30:00 gleixner Exp $
10
10
*/
11
11
12
12
/****************************************************************************/
···
479
479
}
480
480
if (nettel_intel_map.virt) {
481
481
iounmap(nettel_intel_map.virt);
482
-
nettel_intel_map.virt = 0;
482
+
nettel_intel_map.virt = NULL;
483
483
}
484
484
#endif
485
485
}
+2
-2
drivers/mtd/maps/pci.c
+2
-2
drivers/mtd/maps/pci.c
···
7
7
* it under the terms of the GNU General Public License version 2 as
8
8
* published by the Free Software Foundation.
9
9
*
10
-
* $Id: pci.c,v 1.13 2005/11/07 11:14:27 gleixner Exp $
10
+
* $Id: pci.c,v 1.14 2005/11/17 08:20:27 dwmw2 Exp $
11
11
*
12
12
* Generic PCI memory map driver. We support the following boards:
13
13
* - Intel IQ80310 ATU.
···
102
102
memcpy_toio(map->base + map->translate(map, to), from, len);
103
103
}
104
104
105
-
static struct map_info mtd_pci_map = {
105
+
static const struct map_info mtd_pci_map = {
106
106
.phys = NO_XIP,
107
107
.copy_from = mtd_pci_copyfrom,
108
108
.copy_to = mtd_pci_copyto,
+2
-1
drivers/mtd/maps/physmap.c
+2
-1
drivers/mtd/maps/physmap.c
···
1
1
/*
2
-
* $Id: physmap.c,v 1.38 2005/11/07 11:14:28 gleixner Exp $
2
+
* $Id: physmap.c,v 1.39 2005/11/29 14:49:36 gleixner Exp $
3
3
*
4
4
* Normal mappings of chips in physical memory
5
5
*
···
19
19
#include <linux/mtd/map.h>
20
20
#include <linux/config.h>
21
21
#include <linux/mtd/partitions.h>
22
+
#include <linux/mtd/physmap.h>
22
23
23
24
static struct mtd_info *mymtd;
24
25
+2
-2
drivers/mtd/maps/sc520cdp.c
+2
-2
drivers/mtd/maps/sc520cdp.c
···
16
16
* along with this program; if not, write to the Free Software
17
17
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
18
18
*
19
-
* $Id: sc520cdp.c,v 1.22 2005/11/07 11:14:28 gleixner Exp $
19
+
* $Id: sc520cdp.c,v 1.23 2005/11/17 08:20:27 dwmw2 Exp $
20
20
*
21
21
*
22
22
* The SC520CDP is an evaluation board for the Elan SC520 processor available
···
164
164
unsigned long default_address;
165
165
};
166
166
167
-
static struct sc520_par_table par_table[NUM_FLASH_BANKS] =
167
+
static const struct sc520_par_table par_table[NUM_FLASH_BANKS] =
168
168
{
169
169
{ /* Flash Bank #0: selected by ROMCS0 */
170
170
SC520_PAR_ROMCS0,
+1
-1
drivers/mtd/nand/nandsim.c
+1
-1
drivers/mtd/nand/nandsim.c
+2
-4
drivers/mtd/rfd_ftl.c
+2
-4
drivers/mtd/rfd_ftl.c
···
30
30
31
31
#define PREFIX "rfd_ftl: "
32
32
33
-
/* Major device # for FTL device */
34
-
35
-
/* A request for this major has been sent to device@lanana.org */
33
+
/* This major has been assigned by device@lanana.org */
36
34
#ifndef RFD_FTL_MAJOR
37
-
#define RFD_FTL_MAJOR 95
35
+
#define RFD_FTL_MAJOR 256
38
36
#endif
39
37
40
38
/* Maximum number of partitions in an FTL region */
+2
-1
drivers/pcmcia/m32r_cfc.c
+2
-1
drivers/pcmcia/m32r_cfc.c
···
355
355
#ifndef CONFIG_PLAT_USRV
356
356
/* insert interrupt */
357
357
request_irq(irq, pcc_interrupt, 0, "m32r_cfc", pcc_interrupt);
358
+
#ifndef CONFIG_PLAT_MAPPI3
358
359
/* eject interrupt */
359
360
request_irq(irq+1, pcc_interrupt, 0, "m32r_cfc", pcc_interrupt);
360
-
361
+
#endif
361
362
debug(3, "m32r_cfc: enable CFMSK, RDYSEL\n");
362
363
pcc_set(pcc_sockets, (unsigned int)PLD_CFIMASK, 0x01);
363
364
#endif /* CONFIG_PLAT_USRV */
+14
-15
drivers/scsi/megaraid.c
+14
-15
drivers/scsi/megaraid.c
···
380
380
381
381
spin_lock_irqsave(&adapter->lock, flags);
382
382
scb = mega_build_cmd(adapter, scmd, &busy);
383
+
if (!scb)
384
+
goto out;
383
385
384
-
if(scb) {
385
-
scb->state |= SCB_PENDQ;
386
-
list_add_tail(&scb->list, &adapter->pending_list);
386
+
scb->state |= SCB_PENDQ;
387
+
list_add_tail(&scb->list, &adapter->pending_list);
387
388
388
-
/*
389
-
* Check if the HBA is in quiescent state, e.g., during a
390
-
* delete logical drive opertion. If it is, don't run
391
-
* the pending_list.
392
-
*/
393
-
if(atomic_read(&adapter->quiescent) == 0) {
394
-
mega_runpendq(adapter);
395
-
}
396
-
return 0;
397
-
}
389
+
/*
390
+
* Check if the HBA is in quiescent state, e.g., during a
391
+
* delete logical drive opertion. If it is, don't run
392
+
* the pending_list.
393
+
*/
394
+
if (atomic_read(&adapter->quiescent) == 0)
395
+
mega_runpendq(adapter);
396
+
397
+
busy = 0;
398
+
out:
398
399
spin_unlock_irqrestore(&adapter->lock, flags);
399
-
400
400
return busy;
401
401
}
402
402
···
4677
4677
4678
4678
adapter->flag = flag;
4679
4679
spin_lock_init(&adapter->lock);
4680
-
scsi_assign_lock(host, &adapter->lock);
4681
4680
4682
4681
host->cmd_per_lun = max_cmd_per_lun;
4683
4682
host->max_sectors = max_sectors_per_io;
+1
-1
drivers/serial/8250.c
+1
-1
drivers/serial/8250.c
+1
-1
drivers/serial/8250_pci.c
+1
-1
drivers/serial/8250_pci.c
+1
-1
drivers/serial/serial_core.c
+1
-1
drivers/serial/serial_core.c
+3
-3
drivers/serial/serial_cs.c
+3
-3
drivers/serial/serial_cs.c
···
85
85
int multi; /* 1 = multifunction, > 1 = # ports */
86
86
};
87
87
88
-
static struct multi_id multi_id[] = {
88
+
static const struct multi_id multi_id[] = {
89
89
{ MANFID_OMEGA, PRODID_OMEGA_QSP_100, 4 },
90
90
{ MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232, 2 },
91
91
{ MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232_D1, 2 },
···
354
354
355
355
static int simple_config(dev_link_t *link)
356
356
{
357
-
static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
358
-
static int size_table[2] = { 8, 16 };
357
+
static const kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
358
+
static const int size_table[2] = { 8, 16 };
359
359
client_handle_t handle = link->handle;
360
360
struct serial_info *info = link->priv;
361
361
struct serial_cfg_mem *cfg_mem;
+2
-2
drivers/usb/atm/usbatm.c
+2
-2
drivers/usb/atm/usbatm.c
···
879
879
880
880
fail:
881
881
instance->atm_dev = NULL;
882
-
shutdown_atm_dev(atm_dev); /* usbatm_atm_dev_close will eventually be called */
882
+
atm_dev_deregister(atm_dev); /* usbatm_atm_dev_close will eventually be called */
883
883
return ret;
884
884
}
885
885
···
1164
1164
1165
1165
/* ATM finalize */
1166
1166
if (instance->atm_dev)
1167
-
shutdown_atm_dev(instance->atm_dev);
1167
+
atm_dev_deregister(instance->atm_dev);
1168
1168
1169
1169
usbatm_put_instance(instance); /* taken in usbatm_usb_probe */
1170
1170
}
+7
-6
drivers/video/Kconfig
+7
-6
drivers/video/Kconfig
···
534
534
bool "Sun3 framebuffer support"
535
535
depends on (FB = y) && (SUN3 || SUN3X) && BROKEN
536
536
537
+
config FB_SBUS
538
+
bool "SBUS and UPA framebuffers"
539
+
depends on (FB = y) && (SPARC32 || SPARC64)
540
+
help
541
+
Say Y if you want support for SBUS or UPA based frame buffer device.
542
+
537
543
config FB_BW2
538
544
bool "BWtwo support"
539
545
depends on (FB = y) && ((SPARC32 || SPARC64) && FB_SBUS || (SUN3 || SUN3X) && FB_SUN3)
···
552
546
config FB_CG3
553
547
bool "CGthree support"
554
548
depends on (FB = y) && ((SPARC32 || SPARC64) && FB_SBUS || (SUN3 || SUN3X) && FB_SUN3)
549
+
select FB_CFB_FILLRECT
555
550
select FB_CFB_COPYAREA
556
551
select FB_CFB_IMAGEBLIT
557
552
help
···
1216
1209
depends on (FB = y) && EXPERIMENTAL && PCI && MIPS && MIPS_PB1100=y
1217
1210
1218
1211
source "drivers/video/geode/Kconfig"
1219
-
1220
-
config FB_SBUS
1221
-
bool "SBUS and UPA framebuffers"
1222
-
depends on (FB = y) && (SPARC32 || SPARC64)
1223
-
help
1224
-
Say Y if you want support for SBUS or UPA based frame buffer device.
1225
1212
1226
1213
config FB_FFB
1227
1214
bool "Creator/Creator3D/Elite3D support"
+9
-6
drivers/video/cirrusfb.c
+9
-6
drivers/video/cirrusfb.c
···
404
404
struct cirrusfb_regs currentmode;
405
405
int blank_mode;
406
406
407
-
u32 pseudo_palette[17];
407
+
u32 pseudo_palette[16];
408
408
struct { u8 red, green, blue, pad; } palette[256];
409
409
410
410
#ifdef CONFIG_ZORRO
···
1603
1603
1604
1604
switch (info->var.bits_per_pixel) {
1605
1605
case 8:
1606
-
((u8*)(info->pseudo_palette))[regno] = v;
1606
+
cinfo->pseudo_palette[regno] = v;
1607
1607
break;
1608
1608
case 16:
1609
-
((u16*)(info->pseudo_palette))[regno] = v;
1609
+
cinfo->pseudo_palette[regno] = v;
1610
1610
break;
1611
1611
case 24:
1612
1612
case 32:
1613
-
((u32*)(info->pseudo_palette))[regno] = v;
1613
+
cinfo->pseudo_palette[regno] = v;
1614
1614
break;
1615
1615
}
1616
1616
return 0;
···
2020
2020
const struct fb_fillrect *region)
2021
2021
{
2022
2022
int m; /* bytes per pixel */
2023
+
u32 color = (cinfo->info->fix.visual == FB_VISUAL_TRUECOLOR) ?
2024
+
cinfo->pseudo_palette[region->color] : region->color;
2025
+
2023
2026
if(cinfo->info->var.bits_per_pixel == 1) {
2024
2027
cirrusfb_RectFill(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2025
2028
region->dx / 8, region->dy,
2026
2029
region->width / 8, region->height,
2027
-
region->color,
2030
+
color,
2028
2031
cinfo->currentmode.line_length);
2029
2032
} else {
2030
2033
m = ( cinfo->info->var.bits_per_pixel + 7 ) / 8;
2031
2034
cirrusfb_RectFill(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2032
2035
region->dx * m, region->dy,
2033
2036
region->width * m, region->height,
2034
-
region->color,
2037
+
color,
2035
2038
cinfo->currentmode.line_length);
2036
2039
}
2037
2040
return;
+1
-1
drivers/video/console/fbcon_ccw.c
+1
-1
drivers/video/console/fbcon_ccw.c
+3
-10
drivers/video/console/fbcon_rotate.h
+3
-10
drivers/video/console/fbcon_rotate.h
···
21
21
(s == SCROLL_REDRAW || s == SCROLL_MOVE || !(i)->fix.xpanstep) ? \
22
22
(i)->var.xres : (i)->var.xres_virtual; })
23
23
24
-
/*
25
-
* The bitmap is always big endian
26
-
*/
27
-
#if defined(__LITTLE_ENDIAN)
28
-
#define FBCON_BIT(b) (7 - (b))
29
-
#else
30
-
#define FBCON_BIT(b) (b)
31
-
#endif
32
24
33
25
static inline int pattern_test_bit(u32 x, u32 y, u32 pitch, const char *pat)
34
26
{
35
27
u32 tmp = (y * pitch) + x, index = tmp / 8, bit = tmp % 8;
36
28
37
29
pat +=index;
38
-
return (test_bit(FBCON_BIT(bit), (void *)pat));
30
+
return (*pat) & (0x80 >> bit);
39
31
}
40
32
41
33
static inline void pattern_set_bit(u32 x, u32 y, u32 pitch, char *pat)
···
35
43
u32 tmp = (y * pitch) + x, index = tmp / 8, bit = tmp % 8;
36
44
37
45
pat += index;
38
-
set_bit(FBCON_BIT(bit), (void *)pat);
46
+
47
+
(*pat) |= 0x80 >> bit;
39
48
}
40
49
41
50
static inline void rotate_ud(const char *in, char *out, u32 width, u32 height)
+2
fs/9p/vfs_inode.c
+2
fs/9p/vfs_inode.c
+6
fs/dquot.c
+6
fs/dquot.c
···
1513
1513
if (IS_ERR(dentry))
1514
1514
return PTR_ERR(dentry);
1515
1515
1516
+
if (!dentry->d_inode) {
1517
+
error = -ENOENT;
1518
+
goto out;
1519
+
}
1520
+
1516
1521
error = security_quota_on(dentry);
1517
1522
if (!error)
1518
1523
error = vfs_quota_on_inode(dentry->d_inode, type, format_id);
1519
1524
1525
+
out:
1520
1526
dput(dentry);
1521
1527
return error;
1522
1528
}
+1
-11
fs/exec.c
+1
-11
fs/exec.c
···
306
306
struct page *page, unsigned long address)
307
307
{
308
308
struct mm_struct *mm = vma->vm_mm;
309
-
pgd_t * pgd;
310
-
pud_t * pud;
311
-
pmd_t * pmd;
312
309
pte_t * pte;
313
310
spinlock_t *ptl;
314
311
···
313
316
goto out;
314
317
315
318
flush_dcache_page(page);
316
-
pgd = pgd_offset(mm, address);
317
-
pud = pud_alloc(mm, pgd, address);
318
-
if (!pud)
319
-
goto out;
320
-
pmd = pmd_alloc(mm, pud, address);
321
-
if (!pmd)
322
-
goto out;
323
-
pte = pte_alloc_map_lock(mm, pmd, address, &ptl);
319
+
pte = get_locked_pte(mm, address, &ptl);
324
320
if (!pte)
325
321
goto out;
326
322
if (!pte_none(*pte)) {
+1
fs/ext3/resize.c
+1
fs/ext3/resize.c
+25
-12
fs/fuse/dir.c
+25
-12
fs/fuse/dir.c
···
74
74
return 1;
75
75
}
76
76
77
+
static int dir_alias(struct inode *inode)
78
+
{
79
+
if (S_ISDIR(inode->i_mode)) {
80
+
/* Don't allow creating an alias to a directory */
81
+
struct dentry *alias = d_find_alias(inode);
82
+
if (alias) {
83
+
dput(alias);
84
+
return 1;
85
+
}
86
+
}
87
+
return 0;
88
+
}
89
+
90
+
static inline int invalid_nodeid(u64 nodeid)
91
+
{
92
+
return !nodeid || nodeid == FUSE_ROOT_ID;
93
+
}
94
+
77
95
static struct dentry_operations fuse_dentry_operations = {
78
96
.d_revalidate = fuse_dentry_revalidate,
79
97
};
···
115
97
fuse_lookup_init(req, dir, entry, &outarg);
116
98
request_send(fc, req);
117
99
err = req->out.h.error;
118
-
if (!err && (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID))
100
+
if (!err && invalid_nodeid(outarg.nodeid))
119
101
err = -EIO;
120
102
if (!err) {
121
103
inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
···
211
193
}
212
194
213
195
err = -EIO;
214
-
if (!S_ISREG(outentry.attr.mode))
196
+
if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
215
197
goto out_free_ff;
216
198
217
199
inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
···
268
250
fuse_put_request(fc, req);
269
251
return err;
270
252
}
271
-
if (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID) {
253
+
if (invalid_nodeid(outarg.nodeid)) {
272
254
fuse_put_request(fc, req);
273
255
return -EIO;
274
256
}
···
281
263
fuse_put_request(fc, req);
282
264
283
265
/* Don't allow userspace to do really stupid things... */
284
-
if ((inode->i_mode ^ mode) & S_IFMT) {
266
+
if (((inode->i_mode ^ mode) & S_IFMT) || dir_alias(inode)) {
285
267
iput(inode);
286
268
return -EIO;
287
269
}
···
892
874
err = fuse_lookup_iget(dir, entry, &inode);
893
875
if (err)
894
876
return ERR_PTR(err);
895
-
if (inode && S_ISDIR(inode->i_mode)) {
896
-
/* Don't allow creating an alias to a directory */
897
-
struct dentry *alias = d_find_alias(inode);
898
-
if (alias) {
899
-
dput(alias);
900
-
iput(inode);
901
-
return ERR_PTR(-EIO);
902
-
}
877
+
if (inode && dir_alias(inode)) {
878
+
iput(inode);
879
+
return ERR_PTR(-EIO);
903
880
}
904
881
d_add(entry, inode);
905
882
return NULL;
+1
fs/hfsplus/hfsplus_fs.h
+1
fs/hfsplus/hfsplus_fs.h
+7
-5
fs/hfsplus/hfsplus_raw.h
+7
-5
fs/hfsplus/hfsplus_raw.h
···
123
123
} __packed;
124
124
125
125
/* HFS+ volume attributes */
126
-
#define HFSPLUS_VOL_UNMNT (1 << 8)
127
-
#define HFSPLUS_VOL_SPARE_BLK (1 << 9)
128
-
#define HFSPLUS_VOL_NOCACHE (1 << 10)
129
-
#define HFSPLUS_VOL_INCNSTNT (1 << 11)
130
-
#define HFSPLUS_VOL_SOFTLOCK (1 << 15)
126
+
#define HFSPLUS_VOL_UNMNT (1 << 8)
127
+
#define HFSPLUS_VOL_SPARE_BLK (1 << 9)
128
+
#define HFSPLUS_VOL_NOCACHE (1 << 10)
129
+
#define HFSPLUS_VOL_INCNSTNT (1 << 11)
130
+
#define HFSPLUS_VOL_NODEID_REUSED (1 << 12)
131
+
#define HFSPLUS_VOL_JOURNALED (1 << 13)
132
+
#define HFSPLUS_VOL_SOFTLOCK (1 << 15)
131
133
132
134
/* HFS+ BTree node descriptor */
133
135
struct hfs_bnode_desc {
+5
-1
fs/hfsplus/options.c
+5
-1
fs/hfsplus/options.c
···
22
22
opt_umask, opt_uid, opt_gid,
23
23
opt_part, opt_session, opt_nls,
24
24
opt_nodecompose, opt_decompose,
25
-
opt_err
25
+
opt_force, opt_err
26
26
};
27
27
28
28
static match_table_t tokens = {
···
36
36
{ opt_nls, "nls=%s" },
37
37
{ opt_decompose, "decompose" },
38
38
{ opt_nodecompose, "nodecompose" },
39
+
{ opt_force, "force" },
39
40
{ opt_err, NULL }
40
41
};
41
42
···
145
144
break;
146
145
case opt_nodecompose:
147
146
sbi->flags |= HFSPLUS_SB_NODECOMPOSE;
147
+
break;
148
+
case opt_force:
149
+
sbi->flags |= HFSPLUS_SB_FORCE;
148
150
break;
149
151
default:
150
152
return 0;
+20
fs/hfsplus/super.c
+20
fs/hfsplus/super.c
···
251
251
return 0;
252
252
if (!(*flags & MS_RDONLY)) {
253
253
struct hfsplus_vh *vhdr = HFSPLUS_SB(sb).s_vhdr;
254
+
struct hfsplus_sb_info sbi;
255
+
256
+
memset(&sbi, 0, sizeof(struct hfsplus_sb_info));
257
+
sbi.nls = HFSPLUS_SB(sb).nls;
258
+
if (!hfsplus_parse_options(data, &sbi))
259
+
return -EINVAL;
254
260
255
261
if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
256
262
printk("HFS+-fs warning: Filesystem was not cleanly unmounted, "
257
263
"running fsck.hfsplus is recommended. leaving read-only.\n");
258
264
sb->s_flags |= MS_RDONLY;
259
265
*flags |= MS_RDONLY;
266
+
} else if (sbi.flags & HFSPLUS_SB_FORCE) {
267
+
/* nothing */
260
268
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
261
269
printk("HFS+-fs: Filesystem is marked locked, leaving read-only.\n");
270
+
sb->s_flags |= MS_RDONLY;
271
+
*flags |= MS_RDONLY;
272
+
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
273
+
printk("HFS+-fs: Filesystem is marked journaled, leaving read-only.\n");
262
274
sb->s_flags |= MS_RDONLY;
263
275
*flags |= MS_RDONLY;
264
276
}
···
364
352
printk("HFS+-fs warning: Filesystem was not cleanly unmounted, "
365
353
"running fsck.hfsplus is recommended. mounting read-only.\n");
366
354
sb->s_flags |= MS_RDONLY;
355
+
} else if (sbi->flags & HFSPLUS_SB_FORCE) {
356
+
/* nothing */
367
357
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
368
358
if (!silent)
369
359
printk("HFS+-fs: Filesystem is marked locked, mounting read-only.\n");
370
360
sb->s_flags |= MS_RDONLY;
361
+
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
362
+
if (!silent)
363
+
printk("HFS+-fs: write access to a jounaled filesystem is not supported, "
364
+
"use the force option at your own risk, mounting read-only.\n");
365
+
sb->s_flags |= MS_RDONLY;
371
366
}
367
+
sbi->flags &= ~HFSPLUS_SB_FORCE;
372
368
373
369
/* Load metadata objects (B*Trees) */
374
370
HFSPLUS_SB(sb).ext_tree = hfs_btree_open(sb, HFSPLUS_EXT_CNID);
+2
fs/jffs2/fs.c
+2
fs/jffs2/fs.c
···
234
234
c = JFFS2_SB_INFO(inode->i_sb);
235
235
236
236
jffs2_init_inode_info(f);
237
+
down(&f->sem);
237
238
238
239
ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
239
240
···
401
400
402
401
f = JFFS2_INODE_INFO(inode);
403
402
jffs2_init_inode_info(f);
403
+
down(&f->sem);
404
404
405
405
memset(ri, 0, sizeof(*ri));
406
406
/* Set OS-specific defaults for new inodes */
+1
-1
fs/jffs2/super.c
+1
-1
fs/jffs2/super.c
+3
-4
fs/proc/task_mmu.c
+3
-4
fs/proc/task_mmu.c
···
402
402
/*
403
403
* Calculate numa node maps for a vma
404
404
*/
405
-
static struct numa_maps *get_numa_maps(const struct vm_area_struct *vma)
405
+
static struct numa_maps *get_numa_maps(struct vm_area_struct *vma)
406
406
{
407
+
int i;
407
408
struct page *page;
408
409
unsigned long vaddr;
409
-
struct mm_struct *mm = vma->vm_mm;
410
-
int i;
411
410
struct numa_maps *md = kmalloc(sizeof(struct numa_maps), GFP_KERNEL);
412
411
413
412
if (!md)
···
419
420
md->node[i] =0;
420
421
421
422
for (vaddr = vma->vm_start; vaddr < vma->vm_end; vaddr += PAGE_SIZE) {
422
-
page = follow_page(mm, vaddr, 0);
423
+
page = follow_page(vma, vaddr, 0);
423
424
if (page) {
424
425
int count = page_mapcount(page);
425
426
+1
-1
fs/reiserfs/inode.c
+1
-1
fs/reiserfs/inode.c
···
2194
2194
INITIALIZE_PATH(path);
2195
2195
int pos_in_item;
2196
2196
int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2197
-
loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1;
2197
+
loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
2198
2198
int retval;
2199
2199
int use_get_block = 0;
2200
2200
int bytes_copied = 0;
+9
fs/reiserfs/journal.c
+9
fs/reiserfs/journal.c
···
2757
2757
journal->j_cnode_used = 0;
2758
2758
journal->j_must_wait = 0;
2759
2759
2760
+
if (journal->j_cnode_free == 0) {
2761
+
reiserfs_warning(p_s_sb, "journal-2004: Journal cnode memory "
2762
+
"allocation failed (%ld bytes). Journal is "
2763
+
"too large for available memory. Usually "
2764
+
"this is due to a journal that is too large.",
2765
+
sizeof (struct reiserfs_journal_cnode) * num_cnodes);
2766
+
goto free_and_return;
2767
+
}
2768
+
2760
2769
init_journal_hash(p_s_sb);
2761
2770
jl = journal->j_current_jl;
2762
2771
jl->j_list_bitmap = get_list_bitmap(p_s_sb, jl);
+227
-12
include/asm-arm/arch-s3c2410/regs-gpio.h
+227
-12
include/asm-arm/arch-s3c2410/regs-gpio.h
···
21
21
* 10-Mar-2005 LCVR Changed S3C2410_VA to S3C24XX_VA
22
22
* 28-Mar-2005 LCVR Fixed definition of GPB10
23
23
* 26-Oct-2005 BJD Added generic configuration types
24
+
* 27-Nov-2005 LCVR Added definitions to S3C2400 registers
24
25
*/
25
26
26
27
···
55
54
56
55
#define S3C2410_GPIOREG(x) ((x) + S3C24XX_VA_GPIO)
57
56
58
-
/* port A - 22bits, zero in bit X makes pin X output
57
+
/* port A - S3C2410: 22bits, zero in bit X makes pin X output
58
+
* S3C2400: 18bits, zero in bit X makes pin X output
59
59
* 1 makes port special function, this is default
60
60
*/
61
61
#define S3C2410_GPACON S3C2410_GPIOREG(0x00)
62
62
#define S3C2410_GPADAT S3C2410_GPIOREG(0x04)
63
+
64
+
#define S3C2400_GPACON S3C2410_GPIOREG(0x00)
65
+
#define S3C2400_GPADAT S3C2410_GPIOREG(0x04)
63
66
64
67
#define S3C2410_GPA0 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 0)
65
68
#define S3C2410_GPA0_OUT (0<<0)
···
108
103
#define S3C2410_GPA10 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 10)
109
104
#define S3C2410_GPA10_OUT (0<<10)
110
105
#define S3C2410_GPA10_ADDR25 (1<<10)
106
+
#define S3C2400_GPA10_SCKE (1<<10)
111
107
112
108
#define S3C2410_GPA11 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 11)
113
109
#define S3C2410_GPA11_OUT (0<<11)
114
110
#define S3C2410_GPA11_ADDR26 (1<<11)
111
+
#define S3C2400_GPA11_nCAS0 (1<<11)
115
112
116
113
#define S3C2410_GPA12 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 12)
117
114
#define S3C2410_GPA12_OUT (0<<12)
118
115
#define S3C2410_GPA12_nGCS1 (1<<12)
116
+
#define S3C2400_GPA12_nCAS1 (1<<12)
119
117
120
118
#define S3C2410_GPA13 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 13)
121
119
#define S3C2410_GPA13_OUT (0<<13)
122
120
#define S3C2410_GPA13_nGCS2 (1<<13)
121
+
#define S3C2400_GPA13_nGCS1 (1<<13)
123
122
124
123
#define S3C2410_GPA14 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 14)
125
124
#define S3C2410_GPA14_OUT (0<<14)
126
125
#define S3C2410_GPA14_nGCS3 (1<<14)
126
+
#define S3C2400_GPA14_nGCS2 (1<<14)
127
127
128
128
#define S3C2410_GPA15 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 15)
129
129
#define S3C2410_GPA15_OUT (0<<15)
130
130
#define S3C2410_GPA15_nGCS4 (1<<15)
131
+
#define S3C2400_GPA15_nGCS3 (1<<15)
131
132
132
133
#define S3C2410_GPA16 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 16)
133
134
#define S3C2410_GPA16_OUT (0<<16)
134
135
#define S3C2410_GPA16_nGCS5 (1<<16)
136
+
#define S3C2400_GPA16_nGCS4 (1<<16)
135
137
136
138
#define S3C2410_GPA17 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 17)
137
139
#define S3C2410_GPA17_OUT (0<<17)
138
140
#define S3C2410_GPA17_CLE (1<<17)
141
+
#define S3C2400_GPA17_nGCS5 (1<<17)
139
142
140
143
#define S3C2410_GPA18 S3C2410_GPIONO(S3C2410_GPIO_BANKA, 18)
141
144
#define S3C2410_GPA18_OUT (0<<18)
···
165
152
#define S3C2410_GPA22_OUT (0<<22)
166
153
#define S3C2410_GPA22_nFCE (1<<22)
167
154
168
-
/* 0x08 and 0x0c are reserved */
155
+
/* 0x08 and 0x0c are reserved on S3C2410 */
169
156
170
-
/* GPB is 10 IO pins, each configured by 2 bits each in GPBCON.
157
+
/* S3C2410:
158
+
* GPB is 10 IO pins, each configured by 2 bits each in GPBCON.
171
159
* 00 = input, 01 = output, 10=special function, 11=reserved
160
+
161
+
* S3C2400:
162
+
* GPB is 16 IO pins, each configured by 2 bits each in GPBCON.
163
+
* 00 = input, 01 = output, 10=data, 11=special function
164
+
172
165
* bit 0,1 = pin 0, 2,3= pin 1...
173
166
*
174
167
* CPBUP = pull up resistor control, 1=disabled, 0=enabled
···
184
165
#define S3C2410_GPBDAT S3C2410_GPIOREG(0x14)
185
166
#define S3C2410_GPBUP S3C2410_GPIOREG(0x18)
186
167
168
+
#define S3C2400_GPBCON S3C2410_GPIOREG(0x08)
169
+
#define S3C2400_GPBDAT S3C2410_GPIOREG(0x0C)
170
+
#define S3C2400_GPBUP S3C2410_GPIOREG(0x10)
171
+
187
172
/* no i/o pin in port b can have value 3! */
188
173
189
174
#define S3C2410_GPB0 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 0)
190
175
#define S3C2410_GPB0_INP (0x00 << 0)
191
176
#define S3C2410_GPB0_OUTP (0x01 << 0)
192
177
#define S3C2410_GPB0_TOUT0 (0x02 << 0)
178
+
#define S3C2400_GPB0_DATA16 (0x02 << 0)
193
179
194
180
#define S3C2410_GPB1 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 1)
195
181
#define S3C2410_GPB1_INP (0x00 << 2)
196
182
#define S3C2410_GPB1_OUTP (0x01 << 2)
197
183
#define S3C2410_GPB1_TOUT1 (0x02 << 2)
184
+
#define S3C2400_GPB1_DATA17 (0x02 << 2)
198
185
199
186
#define S3C2410_GPB2 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 2)
200
187
#define S3C2410_GPB2_INP (0x00 << 4)
201
188
#define S3C2410_GPB2_OUTP (0x01 << 4)
202
189
#define S3C2410_GPB2_TOUT2 (0x02 << 4)
190
+
#define S3C2400_GPB2_DATA18 (0x02 << 4)
191
+
#define S3C2400_GPB2_TCLK1 (0x03 << 4)
203
192
204
193
#define S3C2410_GPB3 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 3)
205
194
#define S3C2410_GPB3_INP (0x00 << 6)
206
195
#define S3C2410_GPB3_OUTP (0x01 << 6)
207
196
#define S3C2410_GPB3_TOUT3 (0x02 << 6)
197
+
#define S3C2400_GPB3_DATA19 (0x02 << 6)
198
+
#define S3C2400_GPB3_TXD1 (0x03 << 6)
208
199
209
200
#define S3C2410_GPB4 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 4)
210
201
#define S3C2410_GPB4_INP (0x00 << 8)
211
202
#define S3C2410_GPB4_OUTP (0x01 << 8)
212
203
#define S3C2410_GPB4_TCLK0 (0x02 << 8)
204
+
#define S3C2400_GPB4_DATA20 (0x02 << 8)
213
205
#define S3C2410_GPB4_MASK (0x03 << 8)
206
+
#define S3C2400_GPB4_RXD1 (0x03 << 8)
207
+
#define S3C2400_GPB4_MASK (0x03 << 8)
214
208
215
209
#define S3C2410_GPB5 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 5)
216
210
#define S3C2410_GPB5_INP (0x00 << 10)
217
211
#define S3C2410_GPB5_OUTP (0x01 << 10)
218
212
#define S3C2410_GPB5_nXBACK (0x02 << 10)
213
+
#define S3C2400_GPB5_DATA21 (0x02 << 10)
214
+
#define S3C2400_GPB5_nCTS1 (0x03 << 10)
219
215
220
216
#define S3C2410_GPB6 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 6)
221
217
#define S3C2410_GPB6_INP (0x00 << 12)
222
218
#define S3C2410_GPB6_OUTP (0x01 << 12)
223
219
#define S3C2410_GPB6_nXBREQ (0x02 << 12)
220
+
#define S3C2400_GPB6_DATA22 (0x02 << 12)
221
+
#define S3C2400_GPB6_nRTS1 (0x03 << 12)
224
222
225
223
#define S3C2410_GPB7 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 7)
226
224
#define S3C2410_GPB7_INP (0x00 << 14)
227
225
#define S3C2410_GPB7_OUTP (0x01 << 14)
228
226
#define S3C2410_GPB7_nXDACK1 (0x02 << 14)
227
+
#define S3C2400_GPB7_DATA23 (0x02 << 14)
229
228
230
229
#define S3C2410_GPB8 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 8)
231
230
#define S3C2410_GPB8_INP (0x00 << 16)
232
231
#define S3C2410_GPB8_OUTP (0x01 << 16)
233
232
#define S3C2410_GPB8_nXDREQ1 (0x02 << 16)
233
+
#define S3C2400_GPB8_DATA24 (0x02 << 16)
234
234
235
235
#define S3C2410_GPB9 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 9)
236
236
#define S3C2410_GPB9_INP (0x00 << 18)
237
237
#define S3C2410_GPB9_OUTP (0x01 << 18)
238
238
#define S3C2410_GPB9_nXDACK0 (0x02 << 18)
239
+
#define S3C2400_GPB9_DATA25 (0x02 << 18)
240
+
#define S3C2400_GPB9_I2SSDI (0x03 << 18)
239
241
240
242
#define S3C2410_GPB10 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 10)
241
243
#define S3C2410_GPB10_INP (0x00 << 20)
242
244
#define S3C2410_GPB10_OUTP (0x01 << 20)
243
245
#define S3C2410_GPB10_nXDRE0 (0x02 << 20)
246
+
#define S3C2400_GPB10_DATA26 (0x02 << 20)
247
+
#define S3C2400_GPB10_nSS (0x03 << 20)
248
+
249
+
#define S3C2400_GPB11 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 11)
250
+
#define S3C2400_GPB11_INP (0x00 << 22)
251
+
#define S3C2400_GPB11_OUTP (0x01 << 22)
252
+
#define S3C2400_GPB11_DATA27 (0x02 << 22)
253
+
254
+
#define S3C2400_GPB12 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 12)
255
+
#define S3C2400_GPB12_INP (0x00 << 24)
256
+
#define S3C2400_GPB12_OUTP (0x01 << 24)
257
+
#define S3C2400_GPB12_DATA28 (0x02 << 24)
258
+
259
+
#define S3C2400_GPB13 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 13)
260
+
#define S3C2400_GPB13_INP (0x00 << 26)
261
+
#define S3C2400_GPB13_OUTP (0x01 << 26)
262
+
#define S3C2400_GPB13_DATA29 (0x02 << 26)
263
+
264
+
#define S3C2400_GPB14 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 14)
265
+
#define S3C2400_GPB14_INP (0x00 << 28)
266
+
#define S3C2400_GPB14_OUTP (0x01 << 28)
267
+
#define S3C2400_GPB14_DATA30 (0x02 << 28)
268
+
269
+
#define S3C2400_GPB15 S3C2410_GPIONO(S3C2410_GPIO_BANKB, 15)
270
+
#define S3C2400_GPB15_INP (0x00 << 30)
271
+
#define S3C2400_GPB15_OUTP (0x01 << 30)
272
+
#define S3C2400_GPB15_DATA31 (0x02 << 30)
273
+
274
+
#define S3C2410_GPB_PUPDIS(x) (1<<(x))
244
275
245
276
/* Port C consits of 16 GPIO/Special function
246
277
*
···
302
233
#define S3C2410_GPCDAT S3C2410_GPIOREG(0x24)
303
234
#define S3C2410_GPCUP S3C2410_GPIOREG(0x28)
304
235
236
+
#define S3C2400_GPCCON S3C2410_GPIOREG(0x14)
237
+
#define S3C2400_GPCDAT S3C2410_GPIOREG(0x18)
238
+
#define S3C2400_GPCUP S3C2410_GPIOREG(0x1C)
239
+
305
240
#define S3C2410_GPC0 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 0)
306
241
#define S3C2410_GPC0_INP (0x00 << 0)
307
242
#define S3C2410_GPC0_OUTP (0x01 << 0)
308
243
#define S3C2410_GPC0_LEND (0x02 << 0)
244
+
#define S3C2400_GPC0_VD0 (0x02 << 0)
309
245
310
246
#define S3C2410_GPC1 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 1)
311
247
#define S3C2410_GPC1_INP (0x00 << 2)
312
248
#define S3C2410_GPC1_OUTP (0x01 << 2)
313
249
#define S3C2410_GPC1_VCLK (0x02 << 2)
250
+
#define S3C2400_GPC1_VD1 (0x02 << 2)
314
251
315
252
#define S3C2410_GPC2 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 2)
316
253
#define S3C2410_GPC2_INP (0x00 << 4)
317
254
#define S3C2410_GPC2_OUTP (0x01 << 4)
318
255
#define S3C2410_GPC2_VLINE (0x02 << 4)
256
+
#define S3C2400_GPC2_VD2 (0x02 << 4)
319
257
320
258
#define S3C2410_GPC3 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 3)
321
259
#define S3C2410_GPC3_INP (0x00 << 6)
322
260
#define S3C2410_GPC3_OUTP (0x01 << 6)
323
261
#define S3C2410_GPC3_VFRAME (0x02 << 6)
262
+
#define S3C2400_GPC3_VD3 (0x02 << 6)
324
263
325
264
#define S3C2410_GPC4 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 4)
326
265
#define S3C2410_GPC4_INP (0x00 << 8)
327
266
#define S3C2410_GPC4_OUTP (0x01 << 8)
328
267
#define S3C2410_GPC4_VM (0x02 << 8)
268
+
#define S3C2400_GPC4_VD4 (0x02 << 8)
329
269
330
270
#define S3C2410_GPC5 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 5)
331
271
#define S3C2410_GPC5_INP (0x00 << 10)
332
272
#define S3C2410_GPC5_OUTP (0x01 << 10)
333
273
#define S3C2410_GPC5_LCDVF0 (0x02 << 10)
274
+
#define S3C2400_GPC5_VD5 (0x02 << 10)
334
275
335
276
#define S3C2410_GPC6 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 6)
336
277
#define S3C2410_GPC6_INP (0x00 << 12)
337
278
#define S3C2410_GPC6_OUTP (0x01 << 12)
338
279
#define S3C2410_GPC6_LCDVF1 (0x02 << 12)
280
+
#define S3C2400_GPC6_VD6 (0x02 << 12)
339
281
340
282
#define S3C2410_GPC7 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 7)
341
283
#define S3C2410_GPC7_INP (0x00 << 14)
342
284
#define S3C2410_GPC7_OUTP (0x01 << 14)
343
285
#define S3C2410_GPC7_LCDVF2 (0x02 << 14)
286
+
#define S3C2400_GPC7_VD7 (0x02 << 14)
344
287
345
288
#define S3C2410_GPC8 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 8)
346
289
#define S3C2410_GPC8_INP (0x00 << 16)
347
290
#define S3C2410_GPC8_OUTP (0x01 << 16)
348
291
#define S3C2410_GPC8_VD0 (0x02 << 16)
292
+
#define S3C2400_GPC8_VD8 (0x02 << 16)
349
293
350
294
#define S3C2410_GPC9 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 9)
351
295
#define S3C2410_GPC9_INP (0x00 << 18)
352
296
#define S3C2410_GPC9_OUTP (0x01 << 18)
353
297
#define S3C2410_GPC9_VD1 (0x02 << 18)
298
+
#define S3C2400_GPC9_VD9 (0x02 << 18)
354
299
355
300
#define S3C2410_GPC10 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 10)
356
301
#define S3C2410_GPC10_INP (0x00 << 20)
357
302
#define S3C2410_GPC10_OUTP (0x01 << 20)
358
303
#define S3C2410_GPC10_VD2 (0x02 << 20)
304
+
#define S3C2400_GPC10_VD10 (0x02 << 20)
359
305
360
306
#define S3C2410_GPC11 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 11)
361
307
#define S3C2410_GPC11_INP (0x00 << 22)
362
308
#define S3C2410_GPC11_OUTP (0x01 << 22)
363
309
#define S3C2410_GPC11_VD3 (0x02 << 22)
310
+
#define S3C2400_GPC11_VD11 (0x02 << 22)
364
311
365
312
#define S3C2410_GPC12 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 12)
366
313
#define S3C2410_GPC12_INP (0x00 << 24)
367
314
#define S3C2410_GPC12_OUTP (0x01 << 24)
368
315
#define S3C2410_GPC12_VD4 (0x02 << 24)
316
+
#define S3C2400_GPC12_VD12 (0x02 << 24)
369
317
370
318
#define S3C2410_GPC13 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 13)
371
319
#define S3C2410_GPC13_INP (0x00 << 26)
372
320
#define S3C2410_GPC13_OUTP (0x01 << 26)
373
321
#define S3C2410_GPC13_VD5 (0x02 << 26)
322
+
#define S3C2400_GPC13_VD13 (0x02 << 26)
374
323
375
324
#define S3C2410_GPC14 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 14)
376
325
#define S3C2410_GPC14_INP (0x00 << 28)
377
326
#define S3C2410_GPC14_OUTP (0x01 << 28)
378
327
#define S3C2410_GPC14_VD6 (0x02 << 28)
328
+
#define S3C2400_GPC14_VD14 (0x02 << 28)
379
329
380
330
#define S3C2410_GPC15 S3C2410_GPIONO(S3C2410_GPIO_BANKC, 15)
381
331
#define S3C2410_GPC15_INP (0x00 << 30)
382
332
#define S3C2410_GPC15_OUTP (0x01 << 30)
383
333
#define S3C2410_GPC15_VD7 (0x02 << 30)
334
+
#define S3C2400_GPC15_VD15 (0x02 << 30)
384
335
385
-
/* Port D consists of 16 GPIO/Special function
336
+
#define S3C2410_GPC_PUPDIS(x) (1<<(x))
337
+
338
+
/*
339
+
* S3C2410: Port D consists of 16 GPIO/Special function
386
340
*
387
341
* almost identical setup to port b, but the special functions are mostly
388
342
* to do with the video system's data.
343
+
*
344
+
* S3C2400: Port D consists of 11 GPIO/Special function
345
+
*
346
+
* almost identical setup to port c
389
347
*/
390
348
391
349
#define S3C2410_GPDCON S3C2410_GPIOREG(0x30)
392
350
#define S3C2410_GPDDAT S3C2410_GPIOREG(0x34)
393
351
#define S3C2410_GPDUP S3C2410_GPIOREG(0x38)
394
352
353
+
#define S3C2400_GPDCON S3C2410_GPIOREG(0x20)
354
+
#define S3C2400_GPDDAT S3C2410_GPIOREG(0x24)
355
+
#define S3C2400_GPDUP S3C2410_GPIOREG(0x28)
356
+
395
357
#define S3C2410_GPD0 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 0)
396
358
#define S3C2410_GPD0_INP (0x00 << 0)
397
359
#define S3C2410_GPD0_OUTP (0x01 << 0)
398
360
#define S3C2410_GPD0_VD8 (0x02 << 0)
361
+
#define S3C2400_GPD0_VFRAME (0x02 << 0)
399
362
400
363
#define S3C2410_GPD1 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 1)
401
364
#define S3C2410_GPD1_INP (0x00 << 2)
402
365
#define S3C2410_GPD1_OUTP (0x01 << 2)
403
366
#define S3C2410_GPD1_VD9 (0x02 << 2)
367
+
#define S3C2400_GPD1_VM (0x02 << 2)
404
368
405
369
#define S3C2410_GPD2 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 2)
406
370
#define S3C2410_GPD2_INP (0x00 << 4)
407
371
#define S3C2410_GPD2_OUTP (0x01 << 4)
408
372
#define S3C2410_GPD2_VD10 (0x02 << 4)
373
+
#define S3C2400_GPD2_VLINE (0x02 << 4)
409
374
410
375
#define S3C2410_GPD3 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 3)
411
376
#define S3C2410_GPD3_INP (0x00 << 6)
412
377
#define S3C2410_GPD3_OUTP (0x01 << 6)
413
378
#define S3C2410_GPD3_VD11 (0x02 << 6)
379
+
#define S3C2400_GPD3_VCLK (0x02 << 6)
414
380
415
381
#define S3C2410_GPD4 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 4)
416
382
#define S3C2410_GPD4_INP (0x00 << 8)
417
383
#define S3C2410_GPD4_OUTP (0x01 << 8)
418
384
#define S3C2410_GPD4_VD12 (0x02 << 8)
385
+
#define S3C2400_GPD4_LEND (0x02 << 8)
419
386
420
387
#define S3C2410_GPD5 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 5)
421
388
#define S3C2410_GPD5_INP (0x00 << 10)
422
389
#define S3C2410_GPD5_OUTP (0x01 << 10)
423
390
#define S3C2410_GPD5_VD13 (0x02 << 10)
391
+
#define S3C2400_GPD5_TOUT0 (0x02 << 10)
424
392
425
393
#define S3C2410_GPD6 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 6)
426
394
#define S3C2410_GPD6_INP (0x00 << 12)
427
395
#define S3C2410_GPD6_OUTP (0x01 << 12)
428
396
#define S3C2410_GPD6_VD14 (0x02 << 12)
397
+
#define S3C2400_GPD6_TOUT1 (0x02 << 12)
429
398
430
399
#define S3C2410_GPD7 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 7)
431
400
#define S3C2410_GPD7_INP (0x00 << 14)
432
401
#define S3C2410_GPD7_OUTP (0x01 << 14)
433
402
#define S3C2410_GPD7_VD15 (0x02 << 14)
403
+
#define S3C2400_GPD7_TOUT2 (0x02 << 14)
434
404
435
405
#define S3C2410_GPD8 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 8)
436
406
#define S3C2410_GPD8_INP (0x00 << 16)
437
407
#define S3C2410_GPD8_OUTP (0x01 << 16)
438
408
#define S3C2410_GPD8_VD16 (0x02 << 16)
409
+
#define S3C2400_GPD8_TOUT3 (0x02 << 16)
439
410
440
411
#define S3C2410_GPD9 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 9)
441
412
#define S3C2410_GPD9_INP (0x00 << 18)
442
413
#define S3C2410_GPD9_OUTP (0x01 << 18)
443
414
#define S3C2410_GPD9_VD17 (0x02 << 18)
415
+
#define S3C2400_GPD9_TCLK0 (0x02 << 18)
416
+
#define S3C2410_GPD9_MASK (0x03 << 18)
444
417
445
418
#define S3C2410_GPD10 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 10)
446
419
#define S3C2410_GPD10_INP (0x00 << 20)
447
420
#define S3C2410_GPD10_OUTP (0x01 << 20)
448
421
#define S3C2410_GPD10_VD18 (0x02 << 20)
422
+
#define S3C2400_GPD10_nWAIT (0x02 << 20)
449
423
450
424
#define S3C2410_GPD11 S3C2410_GPIONO(S3C2410_GPIO_BANKD, 11)
451
425
#define S3C2410_GPD11_INP (0x00 << 22)
···
515
403
#define S3C2410_GPD15_OUTP (0x01 << 30)
516
404
#define S3C2410_GPD15_VD23 (0x02 << 30)
517
405
518
-
/* Port E consists of 16 GPIO/Special function
406
+
#define S3C2410_GPD_PUPDIS(x) (1<<(x))
407
+
408
+
/* S3C2410:
409
+
* Port E consists of 16 GPIO/Special function
519
410
*
520
411
* again, the same as port B, but dealing with I2S, SDI, and
521
412
* more miscellaneous functions
413
+
*
414
+
* S3C2400:
415
+
* Port E consists of 12 GPIO/Special function
416
+
*
417
+
* GPIO / interrupt inputs
522
418
*/
523
419
524
420
#define S3C2410_GPECON S3C2410_GPIOREG(0x40)
525
421
#define S3C2410_GPEDAT S3C2410_GPIOREG(0x44)
526
422
#define S3C2410_GPEUP S3C2410_GPIOREG(0x48)
527
423
424
+
#define S3C2400_GPECON S3C2410_GPIOREG(0x2C)
425
+
#define S3C2400_GPEDAT S3C2410_GPIOREG(0x30)
426
+
#define S3C2400_GPEUP S3C2410_GPIOREG(0x34)
427
+
528
428
#define S3C2410_GPE0 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 0)
529
429
#define S3C2410_GPE0_INP (0x00 << 0)
530
430
#define S3C2410_GPE0_OUTP (0x01 << 0)
531
431
#define S3C2410_GPE0_I2SLRCK (0x02 << 0)
432
+
#define S3C2400_GPE0_EINT0 (0x02 << 0)
532
433
#define S3C2410_GPE0_MASK (0x03 << 0)
533
434
534
435
#define S3C2410_GPE1 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 1)
535
436
#define S3C2410_GPE1_INP (0x00 << 2)
536
437
#define S3C2410_GPE1_OUTP (0x01 << 2)
537
438
#define S3C2410_GPE1_I2SSCLK (0x02 << 2)
439
+
#define S3C2400_GPE1_EINT1 (0x02 << 2)
440
+
#define S3C2400_GPE1_nSS (0x03 << 2)
538
441
#define S3C2410_GPE1_MASK (0x03 << 2)
539
442
540
443
#define S3C2410_GPE2 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 2)
541
444
#define S3C2410_GPE2_INP (0x00 << 4)
542
445
#define S3C2410_GPE2_OUTP (0x01 << 4)
543
446
#define S3C2410_GPE2_CDCLK (0x02 << 4)
447
+
#define S3C2400_GPE2_EINT2 (0x02 << 4)
448
+
#define S3C2400_GPE2_I2SSDI (0x03 << 4)
544
449
545
450
#define S3C2410_GPE3 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 3)
546
451
#define S3C2410_GPE3_INP (0x00 << 6)
547
452
#define S3C2410_GPE3_OUTP (0x01 << 6)
548
453
#define S3C2410_GPE3_I2SSDI (0x02 << 6)
454
+
#define S3C2400_GPE3_EINT3 (0x02 << 6)
455
+
#define S3C2400_GPE3_nCTS1 (0x03 << 6)
549
456
#define S3C2410_GPE3_nSS0 (0x03 << 6)
550
457
#define S3C2410_GPE3_MASK (0x03 << 6)
551
458
···
572
441
#define S3C2410_GPE4_INP (0x00 << 8)
573
442
#define S3C2410_GPE4_OUTP (0x01 << 8)
574
443
#define S3C2410_GPE4_I2SSDO (0x02 << 8)
444
+
#define S3C2400_GPE4_EINT4 (0x02 << 8)
445
+
#define S3C2400_GPE4_nRTS1 (0x03 << 8)
575
446
#define S3C2410_GPE4_I2SSDI (0x03 << 8)
576
447
#define S3C2410_GPE4_MASK (0x03 << 8)
577
448
···
581
448
#define S3C2410_GPE5_INP (0x00 << 10)
582
449
#define S3C2410_GPE5_OUTP (0x01 << 10)
583
450
#define S3C2410_GPE5_SDCLK (0x02 << 10)
451
+
#define S3C2400_GPE5_EINT5 (0x02 << 10)
452
+
#define S3C2400_GPE5_TCLK1 (0x03 << 10)
584
453
585
454
#define S3C2410_GPE6 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 6)
586
455
#define S3C2410_GPE6_INP (0x00 << 12)
587
456
#define S3C2410_GPE6_OUTP (0x01 << 12)
588
457
#define S3C2410_GPE6_SDCMD (0x02 << 12)
458
+
#define S3C2400_GPE6_EINT6 (0x02 << 12)
589
459
590
460
#define S3C2410_GPE7 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 7)
591
461
#define S3C2410_GPE7_INP (0x00 << 14)
592
462
#define S3C2410_GPE7_OUTP (0x01 << 14)
593
463
#define S3C2410_GPE7_SDDAT0 (0x02 << 14)
464
+
#define S3C2400_GPE7_EINT7 (0x02 << 14)
594
465
595
466
#define S3C2410_GPE8 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 8)
596
467
#define S3C2410_GPE8_INP (0x00 << 16)
597
468
#define S3C2410_GPE8_OUTP (0x01 << 16)
598
469
#define S3C2410_GPE8_SDDAT1 (0x02 << 16)
470
+
#define S3C2400_GPE8_nXDACK0 (0x02 << 16)
599
471
600
472
#define S3C2410_GPE9 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 9)
601
473
#define S3C2410_GPE9_INP (0x00 << 18)
602
474
#define S3C2410_GPE9_OUTP (0x01 << 18)
603
475
#define S3C2410_GPE9_SDDAT2 (0x02 << 18)
476
+
#define S3C2400_GPE9_nXDACK1 (0x02 << 18)
477
+
#define S3C2400_GPE9_nXBACK (0x03 << 18)
604
478
605
479
#define S3C2410_GPE10 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 10)
606
480
#define S3C2410_GPE10_INP (0x00 << 20)
607
481
#define S3C2410_GPE10_OUTP (0x01 << 20)
608
482
#define S3C2410_GPE10_SDDAT3 (0x02 << 20)
483
+
#define S3C2400_GPE10_nXDREQ0 (0x02 << 20)
609
484
610
485
#define S3C2410_GPE11 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 11)
611
486
#define S3C2410_GPE11_INP (0x00 << 22)
612
487
#define S3C2410_GPE11_OUTP (0x01 << 22)
613
488
#define S3C2410_GPE11_SPIMISO0 (0x02 << 22)
489
+
#define S3C2400_GPE11_nXDREQ1 (0x02 << 22)
490
+
#define S3C2400_GPE11_nXBREQ (0x03 << 22)
614
491
615
492
#define S3C2410_GPE12 S3C2410_GPIONO(S3C2410_GPIO_BANKE, 12)
616
493
#define S3C2410_GPE12_INP (0x00 << 24)
···
652
509
653
510
#define S3C2410_GPE_PUPDIS(x) (1<<(x))
654
511
655
-
/* Port F consists of 8 GPIO/Special function
512
+
/* S3C2410:
513
+
* Port F consists of 8 GPIO/Special function
656
514
*
657
515
* GPIO / interrupt inputs
658
516
*
···
661
517
* 00 = 0 input, 1 output, 2 interrupt (EINT0..7), 3 undefined
662
518
*
663
519
* pull up works like all other ports.
520
+
*
521
+
* S3C2400:
522
+
* Port F consists of 7 GPIO/Special function
523
+
*
524
+
* GPIO/serial/misc pins
664
525
*/
665
526
666
527
#define S3C2410_GPFCON S3C2410_GPIOREG(0x50)
667
528
#define S3C2410_GPFDAT S3C2410_GPIOREG(0x54)
668
529
#define S3C2410_GPFUP S3C2410_GPIOREG(0x58)
669
530
531
+
#define S3C2400_GPFCON S3C2410_GPIOREG(0x38)
532
+
#define S3C2400_GPFDAT S3C2410_GPIOREG(0x3C)
533
+
#define S3C2400_GPFUP S3C2410_GPIOREG(0x40)
534
+
670
535
#define S3C2410_GPF0 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 0)
671
536
#define S3C2410_GPF0_INP (0x00 << 0)
672
537
#define S3C2410_GPF0_OUTP (0x01 << 0)
673
538
#define S3C2410_GPF0_EINT0 (0x02 << 0)
539
+
#define S3C2400_GPF0_RXD0 (0x02 << 0)
674
540
675
541
#define S3C2410_GPF1 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 1)
676
542
#define S3C2410_GPF1_INP (0x00 << 2)
677
543
#define S3C2410_GPF1_OUTP (0x01 << 2)
678
544
#define S3C2410_GPF1_EINT1 (0x02 << 2)
545
+
#define S3C2400_GPF1_RXD1 (0x02 << 2)
546
+
#define S3C2400_GPF1_IICSDA (0x03 << 2)
679
547
680
548
#define S3C2410_GPF2 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 2)
681
549
#define S3C2410_GPF2_INP (0x00 << 4)
682
550
#define S3C2410_GPF2_OUTP (0x01 << 4)
683
551
#define S3C2410_GPF2_EINT2 (0x02 << 4)
552
+
#define S3C2400_GPF2_TXD0 (0x02 << 4)
684
553
685
554
#define S3C2410_GPF3 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 3)
686
555
#define S3C2410_GPF3_INP (0x00 << 6)
687
556
#define S3C2410_GPF3_OUTP (0x01 << 6)
688
557
#define S3C2410_GPF3_EINT3 (0x02 << 6)
558
+
#define S3C2400_GPF3_TXD1 (0x02 << 6)
559
+
#define S3C2400_GPF3_IICSCL (0x03 << 6)
689
560
690
561
#define S3C2410_GPF4 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 4)
691
562
#define S3C2410_GPF4_INP (0x00 << 8)
692
563
#define S3C2410_GPF4_OUTP (0x01 << 8)
693
564
#define S3C2410_GPF4_EINT4 (0x02 << 8)
565
+
#define S3C2400_GPF4_nRTS0 (0x02 << 8)
566
+
#define S3C2400_GPF4_nXBACK (0x03 << 8)
694
567
695
568
#define S3C2410_GPF5 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 5)
696
569
#define S3C2410_GPF5_INP (0x00 << 10)
697
570
#define S3C2410_GPF5_OUTP (0x01 << 10)
698
571
#define S3C2410_GPF5_EINT5 (0x02 << 10)
572
+
#define S3C2400_GPF5_nCTS0 (0x02 << 10)
573
+
#define S3C2400_GPF5_nXBREQ (0x03 << 10)
699
574
700
575
#define S3C2410_GPF6 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 6)
701
576
#define S3C2410_GPF6_INP (0x00 << 12)
702
577
#define S3C2410_GPF6_OUTP (0x01 << 12)
703
578
#define S3C2410_GPF6_EINT6 (0x02 << 12)
579
+
#define S3C2400_GPF6_CLKOUT (0x02 << 12)
704
580
705
581
#define S3C2410_GPF7 S3C2410_GPIONO(S3C2410_GPIO_BANKF, 7)
706
582
#define S3C2410_GPF7_INP (0x00 << 14)
707
583
#define S3C2410_GPF7_OUTP (0x01 << 14)
708
584
#define S3C2410_GPF7_EINT7 (0x02 << 14)
709
585
710
-
/* Port G consists of 8 GPIO/IRQ/Special function
586
+
#define S3C2410_GPF_PUPDIS(x) (1<<(x))
587
+
588
+
/* S3C2410:
589
+
* Port G consists of 8 GPIO/IRQ/Special function
711
590
*
712
591
* GPGCON has 2 bits for each of the input pins on port F
713
592
* 00 = 0 input, 1 output, 2 interrupt (EINT0..7), 3 special func
714
593
*
715
594
* pull up works like all other ports.
595
+
*
596
+
* S3C2400:
597
+
* Port G consists of 10 GPIO/Special function
716
598
*/
717
599
718
600
#define S3C2410_GPGCON S3C2410_GPIOREG(0x60)
719
601
#define S3C2410_GPGDAT S3C2410_GPIOREG(0x64)
720
602
#define S3C2410_GPGUP S3C2410_GPIOREG(0x68)
721
603
604
+
#define S3C2400_GPGCON S3C2410_GPIOREG(0x44)
605
+
#define S3C2400_GPGDAT S3C2410_GPIOREG(0x48)
606
+
#define S3C2400_GPGUP S3C2410_GPIOREG(0x4C)
607
+
722
608
#define S3C2410_GPG0 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 0)
723
609
#define S3C2410_GPG0_INP (0x00 << 0)
724
610
#define S3C2410_GPG0_OUTP (0x01 << 0)
725
611
#define S3C2410_GPG0_EINT8 (0x02 << 0)
612
+
#define S3C2400_GPG0_I2SLRCK (0x02 << 0)
726
613
727
614
#define S3C2410_GPG1 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 1)
728
615
#define S3C2410_GPG1_INP (0x00 << 2)
729
616
#define S3C2410_GPG1_OUTP (0x01 << 2)
730
617
#define S3C2410_GPG1_EINT9 (0x02 << 2)
618
+
#define S3C2400_GPG1_I2SSCLK (0x02 << 2)
731
619
732
620
#define S3C2410_GPG2 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 2)
733
621
#define S3C2410_GPG2_INP (0x00 << 4)
734
622
#define S3C2410_GPG2_OUTP (0x01 << 4)
735
623
#define S3C2410_GPG2_EINT10 (0x02 << 4)
624
+
#define S3C2400_GPG2_CDCLK (0x02 << 4)
736
625
737
626
#define S3C2410_GPG3 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 3)
738
627
#define S3C2410_GPG3_INP (0x00 << 6)
739
628
#define S3C2410_GPG3_OUTP (0x01 << 6)
740
629
#define S3C2410_GPG3_EINT11 (0x02 << 6)
630
+
#define S3C2400_GPG3_I2SSDO (0x02 << 6)
631
+
#define S3C2400_GPG3_I2SSDI (0x03 << 6)
741
632
742
633
#define S3C2410_GPG4 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 4)
743
634
#define S3C2410_GPG4_INP (0x00 << 8)
744
635
#define S3C2410_GPG4_OUTP (0x01 << 8)
745
636
#define S3C2410_GPG4_EINT12 (0x02 << 8)
637
+
#define S3C2400_GPG4_MMCCLK (0x02 << 8)
638
+
#define S3C2400_GPG4_I2SSDI (0x03 << 8)
746
639
#define S3C2410_GPG4_LCDPWREN (0x03 << 8)
747
640
748
641
#define S3C2410_GPG5 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 5)
749
642
#define S3C2410_GPG5_INP (0x00 << 10)
750
643
#define S3C2410_GPG5_OUTP (0x01 << 10)
751
644
#define S3C2410_GPG5_EINT13 (0x02 << 10)
645
+
#define S3C2400_GPG5_MMCCMD (0x02 << 10)
646
+
#define S3C2400_GPG5_IICSDA (0x03 << 10)
752
647
#define S3C2410_GPG5_SPIMISO1 (0x03 << 10)
753
648
754
649
#define S3C2410_GPG6 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 6)
755
650
#define S3C2410_GPG6_INP (0x00 << 12)
756
651
#define S3C2410_GPG6_OUTP (0x01 << 12)
757
652
#define S3C2410_GPG6_EINT14 (0x02 << 12)
653
+
#define S3C2400_GPG6_MMCDAT (0x02 << 12)
654
+
#define S3C2400_GPG6_IICSCL (0x03 << 12)
758
655
#define S3C2410_GPG6_SPIMOSI1 (0x03 << 12)
759
656
760
657
#define S3C2410_GPG7 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 7)
···
803
618
#define S3C2410_GPG7_OUTP (0x01 << 14)
804
619
#define S3C2410_GPG7_EINT15 (0x02 << 14)
805
620
#define S3C2410_GPG7_SPICLK1 (0x03 << 14)
621
+
#define S3C2400_GPG7_SPIMISO (0x02 << 14)
622
+
#define S3C2400_GPG7_IICSDA (0x03 << 14)
806
623
807
624
#define S3C2410_GPG8 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 8)
808
625
#define S3C2410_GPG8_INP (0x00 << 16)
809
626
#define S3C2410_GPG8_OUTP (0x01 << 16)
810
627
#define S3C2410_GPG8_EINT16 (0x02 << 16)
628
+
#define S3C2400_GPG8_SPIMOSI (0x02 << 16)
629
+
#define S3C2400_GPG8_IICSCL (0x03 << 16)
811
630
812
631
#define S3C2410_GPG9 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 9)
813
632
#define S3C2410_GPG9_INP (0x00 << 18)
814
633
#define S3C2410_GPG9_OUTP (0x01 << 18)
815
634
#define S3C2410_GPG9_EINT17 (0x02 << 18)
635
+
#define S3C2400_GPG9_SPICLK (0x02 << 18)
636
+
#define S3C2400_GPG9_MMCCLK (0x03 << 18)
816
637
817
638
#define S3C2410_GPG10 S3C2410_GPIONO(S3C2410_GPIO_BANKG, 10)
818
639
#define S3C2410_GPG10_INP (0x00 << 20)
···
928
737
#define S3C2410_GPH10_CLKOUT1 (0x02 << 20)
929
738
930
739
/* miscellaneous control */
931
-
740
+
#define S3C2400_MISCCR S3C2410_GPIOREG(0x54)
932
741
#define S3C2410_MISCCR S3C2410_GPIOREG(0x80)
933
742
#define S3C2410_DCLKCON S3C2410_GPIOREG(0x84)
934
743
935
744
/* see clock.h for dclk definitions */
936
745
937
746
/* pullup control on databus */
938
-
#define S3C2410_MISCCR_SPUCR_HEN (0)
747
+
#define S3C2410_MISCCR_SPUCR_HEN (0<<0)
939
748
#define S3C2410_MISCCR_SPUCR_HDIS (1<<0)
940
-
#define S3C2410_MISCCR_SPUCR_LEN (0)
749
+
#define S3C2410_MISCCR_SPUCR_LEN (0<<1)
941
750
#define S3C2410_MISCCR_SPUCR_LDIS (1<<1)
942
751
943
-
#define S3C2410_MISCCR_USBDEV (0)
752
+
#define S3C2400_MISCCR_SPUCR_LEN (0<<0)
753
+
#define S3C2400_MISCCR_SPUCR_LDIS (1<<0)
754
+
#define S3C2400_MISCCR_SPUCR_HEN (0<<1)
755
+
#define S3C2400_MISCCR_SPUCR_HDIS (1<<1)
756
+
757
+
#define S3C2400_MISCCR_HZ_STOPEN (0<<2)
758
+
#define S3C2400_MISCCR_HZ_STOPPREV (1<<2)
759
+
760
+
#define S3C2410_MISCCR_USBDEV (0<<3)
944
761
#define S3C2410_MISCCR_USBHOST (1<<3)
945
762
946
763
#define S3C2410_MISCCR_CLK0_MPLL (0<<4)
···
984
785
*
985
786
* Samsung datasheet p9-25
986
787
*/
987
-
788
+
#define S3C2400_EXTINT0 S3C2410_GPIOREG(0x58)
988
789
#define S3C2410_EXTINT0 S3C2410_GPIOREG(0x88)
989
790
#define S3C2410_EXTINT1 S3C2410_GPIOREG(0x8C)
990
791
#define S3C2410_EXTINT2 S3C2410_GPIOREG(0x90)
···
1031
832
#define S3C2410_GSTATUS2_WTRESET (1<<2)
1032
833
#define S3C2410_GSTATUS2_OFFRESET (1<<1)
1033
834
#define S3C2410_GSTATUS2_PONRESET (1<<0)
835
+
836
+
/* open drain control register */
837
+
#define S3C2400_OPENCR S3C2410_GPIOREG(0x50)
838
+
839
+
#define S3C2400_OPENCR_OPC_RXD1DIS (0<<0)
840
+
#define S3C2400_OPENCR_OPC_RXD1EN (1<<0)
841
+
#define S3C2400_OPENCR_OPC_TXD1DIS (0<<1)
842
+
#define S3C2400_OPENCR_OPC_TXD1EN (1<<1)
843
+
#define S3C2400_OPENCR_OPC_CMDDIS (0<<2)
844
+
#define S3C2400_OPENCR_OPC_CMDEN (1<<2)
845
+
#define S3C2400_OPENCR_OPC_DATDIS (0<<3)
846
+
#define S3C2400_OPENCR_OPC_DATEN (1<<3)
847
+
#define S3C2400_OPENCR_OPC_MISODIS (0<<4)
848
+
#define S3C2400_OPENCR_OPC_MISOEN (1<<4)
849
+
#define S3C2400_OPENCR_OPC_MOSIDIS (0<<5)
850
+
#define S3C2400_OPENCR_OPC_MOSIEN (1<<5)
1034
851
1035
852
#endif /* __ASM_ARCH_REGS_GPIO_H */
1036
853
-2
include/asm-arm/arch-sa1100/io.h
-2
include/asm-arm/arch-sa1100/io.h
+1
include/asm-frv/hardirq.h
+1
include/asm-frv/hardirq.h
+4
-4
include/asm-frv/ide.h
+4
-4
include/asm-frv/ide.h
···
33
33
/*
34
34
* some bits needed for parts of the IDE subsystem to compile
35
35
*/
36
-
#define __ide_mm_insw(port, addr, n) insw(port, addr, n)
37
-
#define __ide_mm_insl(port, addr, n) insl(port, addr, n)
38
-
#define __ide_mm_outsw(port, addr, n) outsw(port, addr, n)
39
-
#define __ide_mm_outsl(port, addr, n) outsl(port, addr, n)
36
+
#define __ide_mm_insw(port, addr, n) insw((unsigned long) (port), addr, n)
37
+
#define __ide_mm_insl(port, addr, n) insl((unsigned long) (port), addr, n)
38
+
#define __ide_mm_outsw(port, addr, n) outsw((unsigned long) (port), addr, n)
39
+
#define __ide_mm_outsl(port, addr, n) outsl((unsigned long) (port), addr, n)
40
40
41
41
42
42
#endif /* __KERNEL__ */
+2
-2
include/asm-frv/page.h
+2
-2
include/asm-frv/page.h
···
47
47
48
48
#define devmem_is_allowed(pfn) 1
49
49
50
-
#define __pa(vaddr) virt_to_phys((void *) vaddr)
51
-
#define __va(paddr) phys_to_virt((unsigned long) paddr)
50
+
#define __pa(vaddr) virt_to_phys((void *) (unsigned long) (vaddr))
51
+
#define __va(paddr) phys_to_virt((unsigned long) (paddr))
52
52
53
53
#define pfn_to_kaddr(pfn) __va((pfn) << PAGE_SHIFT)
54
54
+1
-1
include/asm-frv/semaphore.h
+1
-1
include/asm-frv/semaphore.h
+1
-1
include/asm-frv/thread_info.h
+1
-1
include/asm-frv/thread_info.h
+2
-1
include/asm-ia64/page.h
+2
-1
include/asm-ia64/page.h
···
110
110
# define pfn_to_page(pfn) (mem_map + (pfn))
111
111
#elif defined(CONFIG_DISCONTIGMEM)
112
112
extern struct page *vmem_map;
113
+
extern unsigned long min_low_pfn;
113
114
extern unsigned long max_low_pfn;
114
-
# define pfn_valid(pfn) (((pfn) < max_low_pfn) && ia64_pfn_valid(pfn))
115
+
# define pfn_valid(pfn) (((pfn) >= min_low_pfn) && ((pfn) < max_low_pfn) && ia64_pfn_valid(pfn))
115
116
# define page_to_pfn(page) ((unsigned long) (page - vmem_map))
116
117
# define pfn_to_page(pfn) (vmem_map + (pfn))
117
118
#endif
+21
include/asm-m32r/atomic.h
+21
include/asm-m32r/atomic.h
···
242
242
*/
243
243
#define atomic_add_negative(i,v) (atomic_add_return((i), (v)) < 0)
244
244
245
+
#define atomic_cmpxchg(v, o, n) ((int)cmpxchg(&((v)->counter), (o), (n)))
246
+
247
+
/**
248
+
* atomic_add_unless - add unless the number is a given value
249
+
* @v: pointer of type atomic_t
250
+
* @a: the amount to add to v...
251
+
* @u: ...unless v is equal to u.
252
+
*
253
+
* Atomically adds @a to @v, so long as it was not @u.
254
+
* Returns non-zero if @v was not @u, and zero otherwise.
255
+
*/
256
+
#define atomic_add_unless(v, a, u) \
257
+
({ \
258
+
int c, old; \
259
+
c = atomic_read(v); \
260
+
while (c != (u) && (old = atomic_cmpxchg((v), c, c + (a))) != c) \
261
+
c = old; \
262
+
c != (u); \
263
+
})
264
+
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
265
+
245
266
static __inline__ void atomic_clear_mask(unsigned long mask, atomic_t *addr)
246
267
{
247
268
unsigned long flags;
+8
-5
include/asm-m32r/ide.h
+8
-5
include/asm-m32r/ide.h
···
25
25
# endif
26
26
#endif
27
27
28
-
#if defined(CONFIG_PLAT_M32700UT)
29
-
#include <asm/irq.h>
30
-
#include <asm/m32700ut/m32700ut_pld.h>
31
-
#endif
28
+
#include <asm/m32r.h>
29
+
32
30
33
31
#define IDE_ARCH_OBSOLETE_DEFAULTS
34
32
35
33
static __inline__ int ide_default_irq(unsigned long base)
36
34
{
37
35
switch (base) {
38
-
#if defined(CONFIG_PLAT_M32700UT) || defined(CONFIG_PLAT_MAPPI2) || defined(CONFIG_PLAT_MAPPI3)
36
+
#if defined(CONFIG_PLAT_M32700UT) || defined(CONFIG_PLAT_MAPPI2)
39
37
case 0x1f0: return PLD_IRQ_CFIREQ;
38
+
default:
39
+
return 0;
40
+
#elif defined(CONFIG_PLAT_MAPPI3)
41
+
case 0x1f0: return PLD_IRQ_CFIREQ;
42
+
case 0x170: return PLD_IRQ_IDEIREQ;
40
43
default:
41
44
return 0;
42
45
#else
+1
-1
include/asm-m32r/mappi3/mappi3_pld.h
+1
-1
include/asm-m32r/mappi3/mappi3_pld.h
···
59
59
#define M32R_IRQ_I2C (28) /* I2C-BUS */
60
60
#define PLD_IRQ_CFIREQ (6) /* INT5 CFC Card Interrupt */
61
61
#define PLD_IRQ_CFC_INSERT (7) /* INT6 CFC Card Insert */
62
-
#define PLD_IRQ_CFC_EJECT (8) /* INT7 CFC Card Eject */
62
+
#define PLD_IRQ_IDEIREQ (8) /* INT7 IDE Interrupt */
63
63
#define PLD_IRQ_MMCCARD (43) /* MMC Card Insert */
64
64
#define PLD_IRQ_MMCIRQ (44) /* MMC Transfer Done */
65
65
+62
-2
include/asm-m32r/system.h
+62
-2
include/asm-m32r/system.h
···
11
11
*/
12
12
13
13
#include <linux/config.h>
14
+
#include <asm/assembler.h>
14
15
15
16
#ifdef __KERNEL__
16
17
···
133
132
!(flags & 0x40); \
134
133
})
135
134
136
-
#endif /* __KERNEL__ */
137
-
138
135
#define nop() __asm__ __volatile__ ("nop" : : )
139
136
140
137
#define xchg(ptr,x) \
···
211
212
212
213
return (tmp);
213
214
}
215
+
216
+
#define __HAVE_ARCH_CMPXCHG 1
217
+
218
+
static __inline__ unsigned long
219
+
__cmpxchg_u32(volatile unsigned int *p, unsigned int old, unsigned int new)
220
+
{
221
+
unsigned long flags;
222
+
unsigned int retval;
223
+
224
+
local_irq_save(flags);
225
+
__asm__ __volatile__ (
226
+
DCACHE_CLEAR("%0", "r4", "%1")
227
+
M32R_LOCK" %0, @%1; \n"
228
+
" bne %0, %2, 1f; \n"
229
+
M32R_UNLOCK" %3, @%1; \n"
230
+
" bra 2f; \n"
231
+
" .fillinsn \n"
232
+
"1:"
233
+
M32R_UNLOCK" %2, @%1; \n"
234
+
" .fillinsn \n"
235
+
"2:"
236
+
: "=&r" (retval)
237
+
: "r" (p), "r" (old), "r" (new)
238
+
: "cbit", "memory"
239
+
#ifdef CONFIG_CHIP_M32700_TS1
240
+
, "r4"
241
+
#endif /* CONFIG_CHIP_M32700_TS1 */
242
+
);
243
+
local_irq_restore(flags);
244
+
245
+
return retval;
246
+
}
247
+
248
+
/* This function doesn't exist, so you'll get a linker error
249
+
if something tries to do an invalid cmpxchg(). */
250
+
extern void __cmpxchg_called_with_bad_pointer(void);
251
+
252
+
static __inline__ unsigned long
253
+
__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
254
+
{
255
+
switch (size) {
256
+
case 4:
257
+
return __cmpxchg_u32(ptr, old, new);
258
+
#if 0 /* we don't have __cmpxchg_u64 */
259
+
case 8:
260
+
return __cmpxchg_u64(ptr, old, new);
261
+
#endif /* 0 */
262
+
}
263
+
__cmpxchg_called_with_bad_pointer();
264
+
return old;
265
+
}
266
+
267
+
#define cmpxchg(ptr,o,n) \
268
+
({ \
269
+
__typeof__(*(ptr)) _o_ = (o); \
270
+
__typeof__(*(ptr)) _n_ = (n); \
271
+
(__typeof__(*(ptr))) __cmpxchg((ptr), (unsigned long)_o_, \
272
+
(unsigned long)_n_, sizeof(*(ptr))); \
273
+
})
274
+
275
+
#endif /* __KERNEL__ */
214
276
215
277
/*
216
278
* Memory barrier.
-10
include/asm-sparc64/pgtable.h
-10
include/asm-sparc64/pgtable.h
···
348
348
struct vm_area_struct;
349
349
extern void update_mmu_cache(struct vm_area_struct *, unsigned long, pte_t);
350
350
351
-
/* Make a non-present pseudo-TTE. */
352
-
static inline pte_t mk_pte_io(unsigned long page, pgprot_t prot, int space)
353
-
{
354
-
pte_t pte;
355
-
pte_val(pte) = (((page) | pgprot_val(prot) | _PAGE_E) &
356
-
~(unsigned long)_PAGE_CACHE);
357
-
pte_val(pte) |= (((unsigned long)space) << 32);
358
-
return pte;
359
-
}
360
-
361
351
/* Encode and de-code a swap entry */
362
352
#define __swp_type(entry) (((entry).val >> PAGE_SHIFT) & 0xffUL)
363
353
#define __swp_offset(entry) ((entry).val >> (PAGE_SHIFT + 8UL))
+9
-9
include/linux/atmdev.h
+9
-9
include/linux/atmdev.h
···
7
7
#define LINUX_ATMDEV_H
8
8
9
9
10
-
#include <linux/config.h>
11
10
#include <linux/atmapi.h>
12
11
#include <linux/atm.h>
13
12
#include <linux/atmioc.h>
···
209
210
210
211
#ifdef __KERNEL__
211
212
213
+
#include <linux/config.h>
212
214
#include <linux/wait.h> /* wait_queue_head_t */
213
215
#include <linux/time.h> /* struct timeval */
214
216
#include <linux/net.h>
···
274
274
275
275
276
276
enum {
277
-
ATM_DF_CLOSE, /* close device when last VCC is closed */
277
+
ATM_DF_REMOVED, /* device was removed from atm_devs list */
278
278
};
279
279
280
280
···
415
415
int number,unsigned long *flags); /* number == -1: pick first available */
416
416
struct atm_dev *atm_dev_lookup(int number);
417
417
void atm_dev_deregister(struct atm_dev *dev);
418
-
void shutdown_atm_dev(struct atm_dev *dev);
419
418
void vcc_insert_socket(struct sock *sk);
420
419
421
420
···
456
457
457
458
static inline void atm_dev_put(struct atm_dev *dev)
458
459
{
459
-
atomic_dec(&dev->refcnt);
460
-
461
-
if ((atomic_read(&dev->refcnt) == 1) &&
462
-
test_bit(ATM_DF_CLOSE,&dev->flags))
463
-
shutdown_atm_dev(dev);
460
+
if (atomic_dec_and_test(&dev->refcnt)) {
461
+
BUG_ON(!test_bit(ATM_DF_REMOVED, &dev->flags));
462
+
if (dev->ops->dev_close)
463
+
dev->ops->dev_close(dev);
464
+
kfree(dev);
465
+
}
464
466
}
465
467
466
468
467
469
int atm_charge(struct atm_vcc *vcc,int truesize);
468
470
struct sk_buff *atm_alloc_charge(struct atm_vcc *vcc,int pdu_size,
469
471
gfp_t gfp_flags);
470
-
int atm_pcr_goal(struct atm_trafprm *tp);
472
+
int atm_pcr_goal(const struct atm_trafprm *tp);
471
473
472
474
void vcc_release_async(struct atm_vcc *vcc, int reply);
473
475
+4
-4
include/linux/cn_proc.h
+4
-4
include/linux/cn_proc.h
···
86
86
pid_t process_pid;
87
87
pid_t process_tgid;
88
88
union {
89
-
uid_t ruid; /* current->uid */
90
-
gid_t rgid; /* current->gid */
89
+
__u32 ruid; /* task uid */
90
+
__u32 rgid; /* task gid */
91
91
} r;
92
92
union {
93
-
uid_t euid;
94
-
gid_t egid;
93
+
__u32 euid;
94
+
__u32 egid;
95
95
} e;
96
96
} id;
97
97
+3
-4
include/linux/cpu.h
+3
-4
include/linux/cpu.h
···
65
65
66
66
#ifdef CONFIG_HOTPLUG_CPU
67
67
/* Stop CPUs going up and down. */
68
-
extern struct semaphore cpucontrol;
69
-
#define lock_cpu_hotplug() down(&cpucontrol)
70
-
#define unlock_cpu_hotplug() up(&cpucontrol)
71
-
#define lock_cpu_hotplug_interruptible() down_interruptible(&cpucontrol)
68
+
extern void lock_cpu_hotplug(void);
69
+
extern void unlock_cpu_hotplug(void);
70
+
extern int lock_cpu_hotplug_interruptible(void);
72
71
#define hotcpu_notifier(fn, pri) { \
73
72
static struct notifier_block fn##_nb = \
74
73
{ .notifier_call = fn, .priority = pri }; \
-1
include/linux/memory.h
-1
include/linux/memory.h
···
85
85
extern int register_memory_notifier(struct notifier_block *nb);
86
86
extern void unregister_memory_notifier(struct notifier_block *nb);
87
87
88
-
extern struct sysdev_class memory_sysdev_class;
89
88
#endif /* CONFIG_MEMORY_HOTPLUG */
90
89
91
90
#define hotplug_memory_notifier(fn, pri) { \
+6
-2
include/linux/mm.h
+6
-2
include/linux/mm.h
···
145
145
#define VM_GROWSDOWN 0x00000100 /* general info on the segment */
146
146
#define VM_GROWSUP 0x00000200
147
147
#define VM_SHM 0x00000000 /* Means nothing: delete it later */
148
-
#define VM_UNPAGED 0x00000400 /* Pages managed without map count */
148
+
#define VM_PFNMAP 0x00000400 /* Page-ranges managed without "struct page", just pure PFN */
149
149
#define VM_DENYWRITE 0x00000800 /* ETXTBSY on write attempts.. */
150
150
151
151
#define VM_EXECUTABLE 0x00001000
···
163
163
#define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */
164
164
#define VM_NONLINEAR 0x00800000 /* Is non-linear (remap_file_pages) */
165
165
#define VM_MAPPED_COPY 0x01000000 /* T if mapped copy of data (nommu mmap) */
166
+
#define VM_INCOMPLETE 0x02000000 /* Strange partial PFN mapping marker */
166
167
167
168
#ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */
168
169
#define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
···
665
664
unsigned long truncate_count; /* Compare vm_truncate_count */
666
665
};
667
666
667
+
struct page *vm_normal_page(struct vm_area_struct *, unsigned long, pte_t);
668
668
unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
669
669
unsigned long size, struct zap_details *);
670
670
unsigned long unmap_vmas(struct mmu_gather **tlb,
···
741
739
struct shrinker;
742
740
extern struct shrinker *set_shrinker(int, shrinker_t);
743
741
extern void remove_shrinker(struct shrinker *shrinker);
742
+
743
+
extern pte_t *FASTCALL(get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl));
744
744
745
745
int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
746
746
int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address);
···
957
953
int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
958
954
unsigned long pfn, unsigned long size, pgprot_t);
959
955
960
-
struct page *follow_page(struct mm_struct *, unsigned long address,
956
+
struct page *follow_page(struct vm_area_struct *, unsigned long address,
961
957
unsigned int foll_flags);
962
958
#define FOLL_WRITE 0x01 /* check pte is writable */
963
959
#define FOLL_TOUCH 0x02 /* mark page accessed */
+2
-2
include/linux/mmc/protocol.h
+2
-2
include/linux/mmc/protocol.h
···
63
63
/* class 5 */
64
64
#define MMC_ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */
65
65
#define MMC_ERASE_GROUP_END 36 /* ac [31:0] data addr R1 */
66
-
#define MMC_ERASE 37 /* ac R1b */
66
+
#define MMC_ERASE 38 /* ac R1b */
67
67
68
68
/* class 9 */
69
69
#define MMC_FAST_IO 39 /* ac <Complex> R4 */
···
74
74
75
75
/* class 8 */
76
76
#define MMC_APP_CMD 55 /* ac [31:16] RCA R1 */
77
-
#define MMC_GEN_CMD 56 /* adtc [0] RD/WR R1b */
77
+
#define MMC_GEN_CMD 56 /* adtc [0] RD/WR R1 */
78
78
79
79
/* SD commands type argument response */
80
80
/* class 8 */
+17
-1
include/linux/mtd/cfi.h
+17
-1
include/linux/mtd/cfi.h
···
1
1
2
2
/* Common Flash Interface structures
3
3
* See http://support.intel.com/design/flash/technote/index.htm
4
-
* $Id: cfi.h,v 1.56 2005/11/07 11:14:54 gleixner Exp $
4
+
* $Id: cfi.h,v 1.57 2005/11/15 23:28:17 tpoynor Exp $
5
5
*/
6
6
7
7
#ifndef __MTD_CFI_H__
···
416
416
417
417
if (map_bankwidth_is_1(map)) {
418
418
return val.x[0];
419
+
} else if (map_bankwidth_is_2(map)) {
420
+
return cfi16_to_cpu(val.x[0]);
421
+
} else {
422
+
/* No point in a 64-bit byteswap since that would just be
423
+
swapping the responses from different chips, and we are
424
+
only interested in one chip (a representative sample) */
425
+
return cfi32_to_cpu(val.x[0]);
426
+
}
427
+
}
428
+
429
+
static inline uint16_t cfi_read_query16(struct map_info *map, uint32_t addr)
430
+
{
431
+
map_word val = map_read(map, addr);
432
+
433
+
if (map_bankwidth_is_1(map)) {
434
+
return val.x[0] & 0xff;
419
435
} else if (map_bankwidth_is_2(map)) {
420
436
return cfi16_to_cpu(val.x[0]);
421
437
} else {
+2
-2
include/linux/rmap.h
+2
-2
include/linux/rmap.h
···
89
89
/*
90
90
* Called from mm/vmscan.c to handle paging out
91
91
*/
92
-
int page_referenced(struct page *, int is_locked, int ignore_token);
92
+
int page_referenced(struct page *, int is_locked);
93
93
int try_to_unmap(struct page *);
94
94
95
95
/*
···
109
109
#define anon_vma_prepare(vma) (0)
110
110
#define anon_vma_link(vma) do {} while (0)
111
111
112
-
#define page_referenced(page,l,i) TestClearPageReferenced(page)
112
+
#define page_referenced(page,l) TestClearPageReferenced(page)
113
113
#define try_to_unmap(page) SWAP_FAIL
114
114
115
115
#endif /* CONFIG_MMU */
-1
include/linux/sched.h
-1
include/linux/sched.h
···
908
908
#define PF_SYNCWRITE 0x00200000 /* I am doing a sync write */
909
909
#define PF_BORROWED_MM 0x00400000 /* I am a kthread doing use_mm */
910
910
#define PF_RANDOMIZE 0x00800000 /* randomize virtual address space */
911
-
#define PF_HOTPLUG_CPU 0x01000000 /* Currently performing CPU hotplug */
912
911
913
912
/*
914
913
* Only the _current_ task can read/write to tsk->flags, but other
+3
include/linux/serial_core.h
+3
include/linux/serial_core.h
+6
include/linux/swap.h
+6
include/linux/swap.h
···
239
239
__put_swap_token(mm);
240
240
}
241
241
242
+
static inline void disable_swap_token(void)
243
+
{
244
+
put_swap_token(swap_token_mm);
245
+
}
246
+
242
247
#else /* CONFIG_SWAP */
243
248
244
249
#define total_swap_pages 0
···
288
283
#define put_swap_token(x) do { } while(0)
289
284
#define grab_swap_token() do { } while(0)
290
285
#define has_swap_token(x) 0
286
+
#define disable_swap_token() do { } while(0)
291
287
292
288
#endif /* CONFIG_SWAP */
293
289
#endif /* __KERNEL__*/
+49
-34
kernel/cpu.c
+49
-34
kernel/cpu.c
···
16
16
#include <asm/semaphore.h>
17
17
18
18
/* This protects CPUs going up and down... */
19
-
DECLARE_MUTEX(cpucontrol);
20
-
EXPORT_SYMBOL_GPL(cpucontrol);
19
+
static DECLARE_MUTEX(cpucontrol);
21
20
22
21
static struct notifier_block *cpu_chain;
23
22
24
-
/*
25
-
* Used to check by callers if they need to acquire the cpucontrol
26
-
* or not to protect a cpu from being removed. Its sometimes required to
27
-
* call these functions both for normal operations, and in response to
28
-
* a cpu being added/removed. If the context of the call is in the same
29
-
* thread context as a CPU hotplug thread, we dont need to take the lock
30
-
* since its already protected
31
-
* check drivers/cpufreq/cpufreq.c for its usage - Ashok Raj
32
-
*/
23
+
#ifdef CONFIG_HOTPLUG_CPU
24
+
static struct task_struct *lock_cpu_hotplug_owner;
25
+
static int lock_cpu_hotplug_depth;
33
26
34
-
int current_in_cpu_hotplug(void)
27
+
static int __lock_cpu_hotplug(int interruptible)
35
28
{
36
-
return (current->flags & PF_HOTPLUG_CPU);
29
+
int ret = 0;
30
+
31
+
if (lock_cpu_hotplug_owner != current) {
32
+
if (interruptible)
33
+
ret = down_interruptible(&cpucontrol);
34
+
else
35
+
down(&cpucontrol);
36
+
}
37
+
38
+
/*
39
+
* Set only if we succeed in locking
40
+
*/
41
+
if (!ret) {
42
+
lock_cpu_hotplug_depth++;
43
+
lock_cpu_hotplug_owner = current;
44
+
}
45
+
46
+
return ret;
37
47
}
38
48
39
-
EXPORT_SYMBOL_GPL(current_in_cpu_hotplug);
49
+
void lock_cpu_hotplug(void)
50
+
{
51
+
__lock_cpu_hotplug(0);
52
+
}
53
+
EXPORT_SYMBOL_GPL(lock_cpu_hotplug);
40
54
55
+
void unlock_cpu_hotplug(void)
56
+
{
57
+
if (--lock_cpu_hotplug_depth == 0) {
58
+
lock_cpu_hotplug_owner = NULL;
59
+
up(&cpucontrol);
60
+
}
61
+
}
62
+
EXPORT_SYMBOL_GPL(unlock_cpu_hotplug);
63
+
64
+
int lock_cpu_hotplug_interruptible(void)
65
+
{
66
+
return __lock_cpu_hotplug(1);
67
+
}
68
+
EXPORT_SYMBOL_GPL(lock_cpu_hotplug_interruptible);
69
+
#endif /* CONFIG_HOTPLUG_CPU */
41
70
42
71
/* Need to know about CPUs going up/down? */
43
72
int register_cpu_notifier(struct notifier_block *nb)
44
73
{
45
74
int ret;
46
75
47
-
if ((ret = down_interruptible(&cpucontrol)) != 0)
76
+
if ((ret = lock_cpu_hotplug_interruptible()) != 0)
48
77
return ret;
49
78
ret = notifier_chain_register(&cpu_chain, nb);
50
-
up(&cpucontrol);
79
+
unlock_cpu_hotplug();
51
80
return ret;
52
81
}
53
82
EXPORT_SYMBOL(register_cpu_notifier);
54
83
55
84
void unregister_cpu_notifier(struct notifier_block *nb)
56
85
{
57
-
down(&cpucontrol);
86
+
lock_cpu_hotplug();
58
87
notifier_chain_unregister(&cpu_chain, nb);
59
-
up(&cpucontrol);
88
+
unlock_cpu_hotplug();
60
89
}
61
90
EXPORT_SYMBOL(unregister_cpu_notifier);
62
91
···
141
112
goto out;
142
113
}
143
114
144
-
/*
145
-
* Leave a trace in current->flags indicating we are already in
146
-
* process of performing CPU hotplug. Callers can check if cpucontrol
147
-
* is already acquired by current thread, and if so not cause
148
-
* a dead lock by not acquiring the lock
149
-
*/
150
-
current->flags |= PF_HOTPLUG_CPU;
151
115
err = notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE,
152
116
(void *)(long)cpu);
153
117
if (err == NOTIFY_BAD) {
···
193
171
out_allowed:
194
172
set_cpus_allowed(current, old_allowed);
195
173
out:
196
-
current->flags &= ~PF_HOTPLUG_CPU;
197
174
unlock_cpu_hotplug();
198
175
return err;
199
176
}
···
203
182
int ret;
204
183
void *hcpu = (void *)(long)cpu;
205
184
206
-
if ((ret = down_interruptible(&cpucontrol)) != 0)
185
+
if ((ret = lock_cpu_hotplug_interruptible()) != 0)
207
186
return ret;
208
187
209
188
if (cpu_online(cpu) || !cpu_present(cpu)) {
···
211
190
goto out;
212
191
}
213
192
214
-
/*
215
-
* Leave a trace in current->flags indicating we are already in
216
-
* process of performing CPU hotplug.
217
-
*/
218
-
current->flags |= PF_HOTPLUG_CPU;
219
193
ret = notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu);
220
194
if (ret == NOTIFY_BAD) {
221
195
printk("%s: attempt to bring up CPU %u failed\n",
···
233
217
if (ret != 0)
234
218
notifier_call_chain(&cpu_chain, CPU_UP_CANCELED, hcpu);
235
219
out:
236
-
current->flags &= ~PF_HOTPLUG_CPU;
237
-
up(&cpucontrol);
220
+
unlock_cpu_hotplug();
238
221
return ret;
239
222
}
+2
-3
kernel/fork.c
+2
-3
kernel/fork.c
···
1124
1124
if (unlikely(p->ptrace & PT_PTRACED))
1125
1125
__ptrace_link(p, current->parent);
1126
1126
1127
-
cpuset_fork(p);
1128
-
1129
1127
attach_pid(p, PIDTYPE_PID, p->pid);
1130
1128
attach_pid(p, PIDTYPE_TGID, p->tgid);
1131
1129
if (thread_group_leader(p)) {
···
1133
1135
__get_cpu_var(process_counts)++;
1134
1136
}
1135
1137
1136
-
proc_fork_connector(p);
1137
1138
if (!current->signal->tty && p->signal->tty)
1138
1139
p->signal->tty = NULL;
1139
1140
1140
1141
nr_threads++;
1141
1142
total_forks++;
1142
1143
write_unlock_irq(&tasklist_lock);
1144
+
proc_fork_connector(p);
1145
+
cpuset_fork(p);
1143
1146
retval = 0;
1144
1147
1145
1148
fork_out:
+1
-1
kernel/posix-cpu-timers.c
+1
-1
kernel/posix-cpu-timers.c
···
36
36
union cpu_time_count ret;
37
37
ret.sched = 0; /* high half always zero when .cpu used */
38
38
if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
39
-
ret.sched = tp->tv_sec * NSEC_PER_SEC + tp->tv_nsec;
39
+
ret.sched = (unsigned long long)tp->tv_sec * NSEC_PER_SEC + tp->tv_nsec;
40
40
} else {
41
41
ret.cpu = timespec_to_cputime(tp);
42
42
}
+16
-5
kernel/power/main.c
+16
-5
kernel/power/main.c
···
24
24
25
25
DECLARE_MUTEX(pm_sem);
26
26
27
-
struct pm_ops * pm_ops = NULL;
27
+
struct pm_ops *pm_ops;
28
28
suspend_disk_method_t pm_disk_mode = PM_DISK_SHUTDOWN;
29
29
30
30
/**
···
151
151
#endif
152
152
};
153
153
154
+
static inline int valid_state(suspend_state_t state)
155
+
{
156
+
/* Suspend-to-disk does not really need low-level support.
157
+
* It can work with reboot if needed. */
158
+
if (state == PM_SUSPEND_DISK)
159
+
return 1;
160
+
161
+
if (pm_ops && pm_ops->valid && !pm_ops->valid(state))
162
+
return 0;
163
+
return 1;
164
+
}
165
+
154
166
155
167
/**
156
168
* enter_state - Do common work of entering low-power state.
···
179
167
{
180
168
int error;
181
169
182
-
if (pm_ops && pm_ops->valid && !pm_ops->valid(state))
170
+
if (!valid_state(state))
183
171
return -ENODEV;
184
172
if (down_trylock(&pm_sem))
185
173
return -EBUSY;
···
250
238
char * s = buf;
251
239
252
240
for (i = 0; i < PM_SUSPEND_MAX; i++) {
253
-
if (pm_states[i] && pm_ops && (!pm_ops->valid
254
-
||(pm_ops->valid && pm_ops->valid(i))))
255
-
s += sprintf(s,"%s ",pm_states[i]);
241
+
if (pm_states[i] && valid_state(i))
242
+
s += sprintf(s,"%s ", pm_states[i]);
256
243
}
257
244
s += sprintf(s,"\n");
258
245
return (s - buf);
+2
-1
kernel/ptrace.c
+2
-1
kernel/ptrace.c
···
241
241
if (write) {
242
242
copy_to_user_page(vma, page, addr,
243
243
maddr + offset, buf, bytes);
244
-
set_page_dirty_lock(page);
244
+
if (!PageCompound(page))
245
+
set_page_dirty_lock(page);
245
246
} else {
246
247
copy_from_user_page(vma, page, addr,
247
248
buf, maddr + offset, bytes);
+6
-6
kernel/workqueue.c
+6
-6
kernel/workqueue.c
···
102
102
103
103
if (!test_and_set_bit(0, &work->pending)) {
104
104
if (unlikely(is_single_threaded(wq)))
105
-
cpu = 0;
105
+
cpu = any_online_cpu(cpu_online_map);
106
106
BUG_ON(!list_empty(&work->entry));
107
107
__queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
108
108
ret = 1;
···
118
118
int cpu = smp_processor_id();
119
119
120
120
if (unlikely(is_single_threaded(wq)))
121
-
cpu = 0;
121
+
cpu = any_online_cpu(cpu_online_map);
122
122
123
123
__queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
124
124
}
···
266
266
might_sleep();
267
267
268
268
if (is_single_threaded(wq)) {
269
-
/* Always use cpu 0's area. */
270
-
flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, 0));
269
+
/* Always use first cpu's area. */
270
+
flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, any_online_cpu(cpu_online_map)));
271
271
} else {
272
272
int cpu;
273
273
···
320
320
lock_cpu_hotplug();
321
321
if (singlethread) {
322
322
INIT_LIST_HEAD(&wq->list);
323
-
p = create_workqueue_thread(wq, 0);
323
+
p = create_workqueue_thread(wq, any_online_cpu(cpu_online_map));
324
324
if (!p)
325
325
destroy = 1;
326
326
else
···
374
374
/* We don't need the distraction of CPUs appearing and vanishing. */
375
375
lock_cpu_hotplug();
376
376
if (is_single_threaded(wq))
377
-
cleanup_workqueue_thread(wq, 0);
377
+
cleanup_workqueue_thread(wq, any_online_cpu(cpu_online_map));
378
378
else {
379
379
for_each_online_cpu(cpu)
380
380
cleanup_workqueue_thread(wq, cpu);
+6
-8
lib/genalloc.c
+6
-8
lib/genalloc.c
···
95
95
if (size > max_chunk_size)
96
96
return 0;
97
97
98
-
i = 0;
99
-
100
98
size = max(size, 1 << ALLOC_MIN_SHIFT);
101
-
s = roundup_pow_of_two(size);
102
-
103
-
j = i;
99
+
i = fls(size - 1);
100
+
s = 1 << i;
101
+
j = i -= ALLOC_MIN_SHIFT;
104
102
105
103
spin_lock_irqsave(&poolp->lock, flags);
106
104
while (!h[j].next) {
···
151
153
if (size > max_chunk_size)
152
154
return;
153
155
154
-
i = 0;
155
-
156
156
size = max(size, 1 << ALLOC_MIN_SHIFT);
157
-
s = roundup_pow_of_two(size);
157
+
i = fls(size - 1);
158
+
s = 1 << i;
159
+
i -= ALLOC_MIN_SHIFT;
158
160
159
161
a = ptr;
160
162
+9
-37
mm/fremap.c
+9
-37
mm/fremap.c
···
27
27
struct page *page = NULL;
28
28
29
29
if (pte_present(pte)) {
30
-
unsigned long pfn = pte_pfn(pte);
31
-
flush_cache_page(vma, addr, pfn);
30
+
flush_cache_page(vma, addr, pte_pfn(pte));
32
31
pte = ptep_clear_flush(vma, addr, ptep);
33
-
if (unlikely(!pfn_valid(pfn))) {
34
-
print_bad_pte(vma, pte, addr);
35
-
goto out;
32
+
page = vm_normal_page(vma, addr, pte);
33
+
if (page) {
34
+
if (pte_dirty(pte))
35
+
set_page_dirty(page);
36
+
page_remove_rmap(page);
37
+
page_cache_release(page);
36
38
}
37
-
page = pfn_to_page(pfn);
38
-
if (pte_dirty(pte))
39
-
set_page_dirty(page);
40
-
page_remove_rmap(page);
41
-
page_cache_release(page);
42
39
} else {
43
40
if (!pte_file(pte))
44
41
free_swap_and_cache(pte_to_swp_entry(pte));
45
42
pte_clear(mm, addr, ptep);
46
43
}
47
-
out:
48
44
return !!page;
49
45
}
50
46
···
55
59
pgoff_t size;
56
60
int err = -ENOMEM;
57
61
pte_t *pte;
58
-
pmd_t *pmd;
59
-
pud_t *pud;
60
-
pgd_t *pgd;
61
62
pte_t pte_val;
62
63
spinlock_t *ptl;
63
64
64
-
BUG_ON(vma->vm_flags & VM_UNPAGED);
65
-
66
-
pgd = pgd_offset(mm, addr);
67
-
pud = pud_alloc(mm, pgd, addr);
68
-
if (!pud)
69
-
goto out;
70
-
pmd = pmd_alloc(mm, pud, addr);
71
-
if (!pmd)
72
-
goto out;
73
-
pte = pte_alloc_map_lock(mm, pmd, addr, &ptl);
65
+
pte = get_locked_pte(mm, addr, &ptl);
74
66
if (!pte)
75
67
goto out;
76
68
···
100
116
{
101
117
int err = -ENOMEM;
102
118
pte_t *pte;
103
-
pmd_t *pmd;
104
-
pud_t *pud;
105
-
pgd_t *pgd;
106
119
pte_t pte_val;
107
120
spinlock_t *ptl;
108
121
109
-
BUG_ON(vma->vm_flags & VM_UNPAGED);
110
-
111
-
pgd = pgd_offset(mm, addr);
112
-
pud = pud_alloc(mm, pgd, addr);
113
-
if (!pud)
114
-
goto out;
115
-
pmd = pmd_alloc(mm, pud, addr);
116
-
if (!pmd)
117
-
goto out;
118
-
pte = pte_alloc_map_lock(mm, pmd, addr, &ptl);
122
+
pte = get_locked_pte(mm, addr, &ptl);
119
123
if (!pte)
120
124
goto out;
121
125
+1
-1
mm/madvise.c
+1
-1
mm/madvise.c
+217
-92
mm/memory.c
+217
-92
mm/memory.c
···
333
333
}
334
334
335
335
/*
336
-
* This function is called to print an error when a pte in a
337
-
* !VM_UNPAGED region is found pointing to an invalid pfn (which
338
-
* is an error.
336
+
* This function is called to print an error when a bad pte
337
+
* is found. For example, we might have a PFN-mapped pte in
338
+
* a region that doesn't allow it.
339
339
*
340
340
* The calling function must still handle the error.
341
341
*/
···
350
350
}
351
351
352
352
/*
353
-
* page_is_anon applies strict checks for an anonymous page belonging to
354
-
* this vma at this address. It is used on VM_UNPAGED vmas, which are
355
-
* usually populated with shared originals (which must not be counted),
356
-
* but occasionally contain private COWed copies (when !VM_SHARED, or
357
-
* perhaps via ptrace when VM_SHARED). An mmap of /dev/mem might window
358
-
* free pages, pages from other processes, or from other parts of this:
359
-
* it's tricky, but try not to be deceived by foreign anonymous pages.
353
+
* This function gets the "struct page" associated with a pte.
354
+
*
355
+
* NOTE! Some mappings do not have "struct pages". A raw PFN mapping
356
+
* will have each page table entry just pointing to a raw page frame
357
+
* number, and as far as the VM layer is concerned, those do not have
358
+
* pages associated with them - even if the PFN might point to memory
359
+
* that otherwise is perfectly fine and has a "struct page".
360
+
*
361
+
* The way we recognize those mappings is through the rules set up
362
+
* by "remap_pfn_range()": the vma will have the VM_PFNMAP bit set,
363
+
* and the vm_pgoff will point to the first PFN mapped: thus every
364
+
* page that is a raw mapping will always honor the rule
365
+
*
366
+
* pfn_of_page == vma->vm_pgoff + ((addr - vma->vm_start) >> PAGE_SHIFT)
367
+
*
368
+
* and if that isn't true, the page has been COW'ed (in which case it
369
+
* _does_ have a "struct page" associated with it even if it is in a
370
+
* VM_PFNMAP range).
360
371
*/
361
-
static inline int page_is_anon(struct page *page,
362
-
struct vm_area_struct *vma, unsigned long addr)
372
+
struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr, pte_t pte)
363
373
{
364
-
return page && PageAnon(page) && page_mapped(page) &&
365
-
page_address_in_vma(page, vma) == addr;
374
+
unsigned long pfn = pte_pfn(pte);
375
+
376
+
if (vma->vm_flags & VM_PFNMAP) {
377
+
unsigned long off = (addr - vma->vm_start) >> PAGE_SHIFT;
378
+
if (pfn == vma->vm_pgoff + off)
379
+
return NULL;
380
+
}
381
+
382
+
/*
383
+
* Add some anal sanity checks for now. Eventually,
384
+
* we should just do "return pfn_to_page(pfn)", but
385
+
* in the meantime we check that we get a valid pfn,
386
+
* and that the resulting page looks ok.
387
+
*
388
+
* Remove this test eventually!
389
+
*/
390
+
if (unlikely(!pfn_valid(pfn))) {
391
+
print_bad_pte(vma, pte, addr);
392
+
return NULL;
393
+
}
394
+
395
+
/*
396
+
* NOTE! We still have PageReserved() pages in the page
397
+
* tables.
398
+
*
399
+
* The PAGE_ZERO() pages and various VDSO mappings can
400
+
* cause them to exist.
401
+
*/
402
+
return pfn_to_page(pfn);
366
403
}
367
404
368
405
/*
···
416
379
unsigned long vm_flags = vma->vm_flags;
417
380
pte_t pte = *src_pte;
418
381
struct page *page;
419
-
unsigned long pfn;
420
382
421
383
/* pte contains position in swap or file, so copy. */
422
384
if (unlikely(!pte_present(pte))) {
···
431
395
}
432
396
}
433
397
goto out_set_pte;
434
-
}
435
-
436
-
pfn = pte_pfn(pte);
437
-
page = pfn_valid(pfn)? pfn_to_page(pfn): NULL;
438
-
439
-
if (unlikely(vm_flags & VM_UNPAGED))
440
-
if (!page_is_anon(page, vma, addr))
441
-
goto out_set_pte;
442
-
443
-
/*
444
-
* If the pte points outside of valid memory but
445
-
* the region is not VM_UNPAGED, we have a problem.
446
-
*/
447
-
if (unlikely(!page)) {
448
-
print_bad_pte(vma, pte, addr);
449
-
goto out_set_pte; /* try to do something sane */
450
398
}
451
399
452
400
/*
···
449
429
if (vm_flags & VM_SHARED)
450
430
pte = pte_mkclean(pte);
451
431
pte = pte_mkold(pte);
452
-
get_page(page);
453
-
page_dup_rmap(page);
454
-
rss[!!PageAnon(page)]++;
432
+
433
+
page = vm_normal_page(vma, addr, pte);
434
+
if (page) {
435
+
get_page(page);
436
+
page_dup_rmap(page);
437
+
rss[!!PageAnon(page)]++;
438
+
}
455
439
456
440
out_set_pte:
457
441
set_pte_at(dst_mm, addr, dst_pte, pte);
···
567
543
* readonly mappings. The tradeoff is that copy_page_range is more
568
544
* efficient than faulting.
569
545
*/
570
-
if (!(vma->vm_flags & (VM_HUGETLB|VM_NONLINEAR|VM_UNPAGED))) {
546
+
if (!(vma->vm_flags & (VM_HUGETLB|VM_NONLINEAR|VM_PFNMAP))) {
571
547
if (!vma->anon_vma)
572
548
return 0;
573
549
}
···
608
584
}
609
585
if (pte_present(ptent)) {
610
586
struct page *page;
611
-
unsigned long pfn;
612
587
613
588
(*zap_work) -= PAGE_SIZE;
614
589
615
-
pfn = pte_pfn(ptent);
616
-
page = pfn_valid(pfn)? pfn_to_page(pfn): NULL;
617
-
618
-
if (unlikely(vma->vm_flags & VM_UNPAGED)) {
619
-
if (!page_is_anon(page, vma, addr))
620
-
page = NULL;
621
-
} else if (unlikely(!page))
622
-
print_bad_pte(vma, ptent, addr);
623
-
590
+
page = vm_normal_page(vma, addr, ptent);
624
591
if (unlikely(details) && page) {
625
592
/*
626
593
* unmap_shared_mapping_pages() wants to
···
867
852
/*
868
853
* Do a quick page-table lookup for a single page.
869
854
*/
870
-
struct page *follow_page(struct mm_struct *mm, unsigned long address,
855
+
struct page *follow_page(struct vm_area_struct *vma, unsigned long address,
871
856
unsigned int flags)
872
857
{
873
858
pgd_t *pgd;
···
875
860
pmd_t *pmd;
876
861
pte_t *ptep, pte;
877
862
spinlock_t *ptl;
878
-
unsigned long pfn;
879
863
struct page *page;
864
+
struct mm_struct *mm = vma->vm_mm;
880
865
881
866
page = follow_huge_addr(mm, address, flags & FOLL_WRITE);
882
867
if (!IS_ERR(page)) {
···
912
897
goto unlock;
913
898
if ((flags & FOLL_WRITE) && !pte_write(pte))
914
899
goto unlock;
915
-
pfn = pte_pfn(pte);
916
-
if (!pfn_valid(pfn))
900
+
page = vm_normal_page(vma, address, pte);
901
+
if (unlikely(!page))
917
902
goto unlock;
918
903
919
-
page = pfn_to_page(pfn);
920
904
if (flags & FOLL_GET)
921
905
get_page(page);
922
906
if (flags & FOLL_TOUCH) {
···
988
974
return i ? : -EFAULT;
989
975
}
990
976
if (pages) {
991
-
pages[i] = pte_page(*pte);
992
-
get_page(pages[i]);
977
+
struct page *page = vm_normal_page(gate_vma, start, *pte);
978
+
pages[i] = page;
979
+
if (page)
980
+
get_page(page);
993
981
}
994
982
pte_unmap(pte);
995
983
if (vmas)
···
1026
1010
foll_flags |= FOLL_WRITE;
1027
1011
1028
1012
cond_resched();
1029
-
while (!(page = follow_page(mm, start, foll_flags))) {
1013
+
while (!(page = follow_page(vma, start, foll_flags))) {
1030
1014
int ret;
1031
1015
ret = __handle_mm_fault(mm, vma, start,
1032
1016
foll_flags & FOLL_WRITE);
···
1146
1130
return err;
1147
1131
}
1148
1132
1133
+
pte_t * fastcall get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl)
1134
+
{
1135
+
pgd_t * pgd = pgd_offset(mm, addr);
1136
+
pud_t * pud = pud_alloc(mm, pgd, addr);
1137
+
if (pud) {
1138
+
pmd_t * pmd = pmd_alloc(mm, pud, addr);
1139
+
if (pmd)
1140
+
return pte_alloc_map_lock(mm, pmd, addr, ptl);
1141
+
}
1142
+
return NULL;
1143
+
}
1144
+
1145
+
/*
1146
+
* This is the old fallback for page remapping.
1147
+
*
1148
+
* For historical reasons, it only allows reserved pages. Only
1149
+
* old drivers should use this, and they needed to mark their
1150
+
* pages reserved for the old functions anyway.
1151
+
*/
1152
+
static int insert_page(struct mm_struct *mm, unsigned long addr, struct page *page, pgprot_t prot)
1153
+
{
1154
+
int retval;
1155
+
pte_t *pte;
1156
+
spinlock_t *ptl;
1157
+
1158
+
retval = -EINVAL;
1159
+
if (PageAnon(page) || !PageReserved(page))
1160
+
goto out;
1161
+
retval = -ENOMEM;
1162
+
flush_dcache_page(page);
1163
+
pte = get_locked_pte(mm, addr, &ptl);
1164
+
if (!pte)
1165
+
goto out;
1166
+
retval = -EBUSY;
1167
+
if (!pte_none(*pte))
1168
+
goto out_unlock;
1169
+
1170
+
/* Ok, finally just insert the thing.. */
1171
+
get_page(page);
1172
+
inc_mm_counter(mm, file_rss);
1173
+
page_add_file_rmap(page);
1174
+
set_pte_at(mm, addr, pte, mk_pte(page, prot));
1175
+
1176
+
retval = 0;
1177
+
out_unlock:
1178
+
pte_unmap_unlock(pte, ptl);
1179
+
out:
1180
+
return retval;
1181
+
}
1182
+
1183
+
/*
1184
+
* Somebody does a pfn remapping that doesn't actually work as a vma.
1185
+
*
1186
+
* Do it as individual pages instead, and warn about it. It's bad form,
1187
+
* and very inefficient.
1188
+
*/
1189
+
static int incomplete_pfn_remap(struct vm_area_struct *vma,
1190
+
unsigned long start, unsigned long end,
1191
+
unsigned long pfn, pgprot_t prot)
1192
+
{
1193
+
static int warn = 10;
1194
+
struct page *page;
1195
+
int retval;
1196
+
1197
+
if (!(vma->vm_flags & VM_INCOMPLETE)) {
1198
+
if (warn) {
1199
+
warn--;
1200
+
printk("%s does an incomplete pfn remapping", current->comm);
1201
+
dump_stack();
1202
+
}
1203
+
}
1204
+
vma->vm_flags |= VM_INCOMPLETE | VM_IO | VM_RESERVED;
1205
+
1206
+
if (start < vma->vm_start || end > vma->vm_end)
1207
+
return -EINVAL;
1208
+
1209
+
if (!pfn_valid(pfn))
1210
+
return -EINVAL;
1211
+
1212
+
retval = 0;
1213
+
page = pfn_to_page(pfn);
1214
+
while (start < end) {
1215
+
retval = insert_page(vma->vm_mm, start, page, prot);
1216
+
if (retval < 0)
1217
+
break;
1218
+
start += PAGE_SIZE;
1219
+
page++;
1220
+
}
1221
+
return retval;
1222
+
}
1223
+
1149
1224
/*
1150
1225
* maps a range of physical memory into the requested pages. the old
1151
1226
* mappings are removed. any references to nonexistent pages results
···
1311
1204
struct mm_struct *mm = vma->vm_mm;
1312
1205
int err;
1313
1206
1207
+
if (addr != vma->vm_start || end != vma->vm_end)
1208
+
return incomplete_pfn_remap(vma, addr, end, pfn, prot);
1209
+
1314
1210
/*
1315
1211
* Physically remapped pages are special. Tell the
1316
1212
* rest of the world about it:
···
1324
1214
* in 2.6 the LRU scan won't even find its pages, so this
1325
1215
* flag means no more than count its pages in reserved_vm,
1326
1216
* and omit it from core dump, even when VM_IO turned off.
1327
-
* VM_UNPAGED tells the core MM not to "manage" these pages
1328
-
* (e.g. refcount, mapcount, try to swap them out): in
1329
-
* particular, zap_pte_range does not try to free them.
1217
+
* VM_PFNMAP tells the core MM that the base pages are just
1218
+
* raw PFN mappings, and do not have a "struct page" associated
1219
+
* with them.
1330
1220
*/
1331
-
vma->vm_flags |= VM_IO | VM_RESERVED | VM_UNPAGED;
1221
+
vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP;
1222
+
vma->vm_pgoff = pfn;
1332
1223
1333
1224
BUG_ON(addr >= end);
1334
1225
pfn -= addr >> PAGE_SHIFT;
···
1384
1273
return pte;
1385
1274
}
1386
1275
1276
+
static inline void cow_user_page(struct page *dst, struct page *src, unsigned long va)
1277
+
{
1278
+
/*
1279
+
* If the source page was a PFN mapping, we don't have
1280
+
* a "struct page" for it. We do a best-effort copy by
1281
+
* just copying from the original user address. If that
1282
+
* fails, we just zero-fill it. Live with it.
1283
+
*/
1284
+
if (unlikely(!src)) {
1285
+
void *kaddr = kmap_atomic(dst, KM_USER0);
1286
+
void __user *uaddr = (void __user *)(va & PAGE_MASK);
1287
+
1288
+
/*
1289
+
* This really shouldn't fail, because the page is there
1290
+
* in the page tables. But it might just be unreadable,
1291
+
* in which case we just give up and fill the result with
1292
+
* zeroes.
1293
+
*/
1294
+
if (__copy_from_user_inatomic(kaddr, uaddr, PAGE_SIZE))
1295
+
memset(kaddr, 0, PAGE_SIZE);
1296
+
kunmap_atomic(kaddr, KM_USER0);
1297
+
return;
1298
+
1299
+
}
1300
+
copy_user_highpage(dst, src, va);
1301
+
}
1302
+
1387
1303
/*
1388
1304
* This routine handles present pages, when users try to write
1389
1305
* to a shared page. It is done by copying the page to a new address
···
1433
1295
unsigned long address, pte_t *page_table, pmd_t *pmd,
1434
1296
spinlock_t *ptl, pte_t orig_pte)
1435
1297
{
1436
-
struct page *old_page, *src_page, *new_page;
1437
-
unsigned long pfn = pte_pfn(orig_pte);
1298
+
struct page *old_page, *new_page;
1438
1299
pte_t entry;
1439
1300
int ret = VM_FAULT_MINOR;
1440
1301
1441
-
if (unlikely(!pfn_valid(pfn))) {
1442
-
/*
1443
-
* Page table corrupted: show pte and kill process.
1444
-
* Or it's an attempt to COW an out-of-map VM_UNPAGED
1445
-
* entry, which copy_user_highpage does not support.
1446
-
*/
1447
-
print_bad_pte(vma, orig_pte, address);
1448
-
ret = VM_FAULT_OOM;
1449
-
goto unlock;
1450
-
}
1451
-
old_page = pfn_to_page(pfn);
1452
-
src_page = old_page;
1453
-
1454
-
if (unlikely(vma->vm_flags & VM_UNPAGED))
1455
-
if (!page_is_anon(old_page, vma, address)) {
1456
-
old_page = NULL;
1457
-
goto gotten;
1458
-
}
1302
+
old_page = vm_normal_page(vma, address, orig_pte);
1303
+
if (!old_page)
1304
+
goto gotten;
1459
1305
1460
1306
if (PageAnon(old_page) && !TestSetPageLocked(old_page)) {
1461
1307
int reuse = can_share_swap_page(old_page);
1462
1308
unlock_page(old_page);
1463
1309
if (reuse) {
1464
-
flush_cache_page(vma, address, pfn);
1310
+
flush_cache_page(vma, address, pte_pfn(orig_pte));
1465
1311
entry = pte_mkyoung(orig_pte);
1466
1312
entry = maybe_mkwrite(pte_mkdirty(entry), vma);
1467
1313
ptep_set_access_flags(vma, address, page_table, entry, 1);
···
1465
1343
1466
1344
if (unlikely(anon_vma_prepare(vma)))
1467
1345
goto oom;
1468
-
if (src_page == ZERO_PAGE(address)) {
1346
+
if (old_page == ZERO_PAGE(address)) {
1469
1347
new_page = alloc_zeroed_user_highpage(vma, address);
1470
1348
if (!new_page)
1471
1349
goto oom;
···
1473
1351
new_page = alloc_page_vma(GFP_HIGHUSER, vma, address);
1474
1352
if (!new_page)
1475
1353
goto oom;
1476
-
copy_user_highpage(new_page, src_page, address);
1354
+
cow_user_page(new_page, old_page, address);
1477
1355
}
1478
1356
1479
1357
/*
···
1489
1367
}
1490
1368
} else
1491
1369
inc_mm_counter(mm, anon_rss);
1492
-
flush_cache_page(vma, address, pfn);
1370
+
flush_cache_page(vma, address, pte_pfn(orig_pte));
1493
1371
entry = mk_pte(new_page, vma->vm_page_prot);
1494
1372
entry = maybe_mkwrite(pte_mkdirty(entry), vma);
1495
1373
ptep_establish(vma, address, page_table, entry);
···
1934
1812
spinlock_t *ptl;
1935
1813
pte_t entry;
1936
1814
1937
-
/*
1938
-
* A VM_UNPAGED vma will normally be filled with present ptes
1939
-
* by remap_pfn_range, and never arrive here; but it might have
1940
-
* holes, or if !VM_DONTEXPAND, mremap might have expanded it.
1941
-
* It's weird enough handling anon pages in unpaged vmas, we do
1942
-
* not want to worry about ZERO_PAGEs too (it may or may not
1943
-
* matter if their counts wrap): just give them anon pages.
1944
-
*/
1945
-
1946
-
if (write_access || (vma->vm_flags & VM_UNPAGED)) {
1815
+
if (write_access) {
1947
1816
/* Allocate our own private page. */
1948
1817
pte_unmap(page_table);
1949
1818
···
2009
1896
int anon = 0;
2010
1897
2011
1898
pte_unmap(page_table);
2012
-
BUG_ON(vma->vm_flags & VM_UNPAGED);
1899
+
BUG_ON(vma->vm_flags & VM_PFNMAP);
2013
1900
2014
1901
if (vma->vm_file) {
2015
1902
mapping = vma->vm_file->f_mapping;
···
2262
2149
spin_unlock(&mm->page_table_lock);
2263
2150
return 0;
2264
2151
}
2152
+
#else
2153
+
/* Workaround for gcc 2.96 */
2154
+
int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
2155
+
{
2156
+
return 0;
2157
+
}
2265
2158
#endif /* __PAGETABLE_PUD_FOLDED */
2266
2159
2267
2160
#ifndef __PAGETABLE_PMD_FOLDED
···
2294
2175
pgd_populate(mm, pud, new);
2295
2176
#endif /* __ARCH_HAS_4LEVEL_HACK */
2296
2177
spin_unlock(&mm->page_table_lock);
2178
+
return 0;
2179
+
}
2180
+
#else
2181
+
/* Workaround for gcc 2.96 */
2182
+
int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
2183
+
{
2297
2184
return 0;
2298
2185
}
2299
2186
#endif /* __PAGETABLE_PMD_FOLDED */
+4
-8
mm/mempolicy.c
+4
-8
mm/mempolicy.c
···
189
189
190
190
orig_pte = pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
191
191
do {
192
-
unsigned long pfn;
192
+
struct page *page;
193
193
unsigned int nid;
194
194
195
195
if (!pte_present(*pte))
196
196
continue;
197
-
pfn = pte_pfn(*pte);
198
-
if (!pfn_valid(pfn)) {
199
-
print_bad_pte(vma, *pte, addr);
197
+
page = vm_normal_page(vma, addr, *pte);
198
+
if (!page)
200
199
continue;
201
-
}
202
-
nid = pfn_to_nid(pfn);
200
+
nid = page_to_nid(page);
203
201
if (!node_isset(nid, *nodes))
204
202
break;
205
203
} while (pte++, addr += PAGE_SIZE, addr != end);
···
267
269
first = find_vma(mm, start);
268
270
if (!first)
269
271
return ERR_PTR(-EFAULT);
270
-
if (first->vm_flags & VM_UNPAGED)
271
-
return ERR_PTR(-EACCES);
272
272
prev = NULL;
273
273
for (vma = first; vma && vma->vm_start < end; vma = vma->vm_next) {
274
274
if (!vma->vm_next && vma->vm_end < end)
+3
-9
mm/msync.c
+3
-9
mm/msync.c
···
27
27
again:
28
28
pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
29
29
do {
30
-
unsigned long pfn;
31
30
struct page *page;
32
31
33
32
if (progress >= 64) {
···
39
40
continue;
40
41
if (!pte_maybe_dirty(*pte))
41
42
continue;
42
-
pfn = pte_pfn(*pte);
43
-
if (unlikely(!pfn_valid(pfn))) {
44
-
print_bad_pte(vma, *pte, addr);
43
+
page = vm_normal_page(vma, addr, *pte);
44
+
if (!page)
45
45
continue;
46
-
}
47
-
page = pfn_to_page(pfn);
48
-
49
46
if (ptep_clear_flush_dirty(vma, addr, pte) ||
50
47
page_test_and_clear_dirty(page))
51
48
set_page_dirty(page);
···
92
97
/* For hugepages we can't go walking the page table normally,
93
98
* but that's ok, hugetlbfs is memory based, so we don't need
94
99
* to do anything more on an msync().
95
-
* Can't do anything with VM_UNPAGED regions either.
96
100
*/
97
-
if (vma->vm_flags & (VM_HUGETLB|VM_UNPAGED))
101
+
if (vma->vm_flags & VM_HUGETLB)
98
102
return;
99
103
100
104
BUG_ON(addr >= end);
+1
-1
mm/nommu.c
+1
-1
mm/nommu.c
+17
-7
mm/page_alloc.c
+17
-7
mm/page_alloc.c
···
773
773
}
774
774
775
775
#define ALLOC_NO_WATERMARKS 0x01 /* don't check watermarks at all */
776
-
#define ALLOC_HARDER 0x02 /* try to alloc harder */
777
-
#define ALLOC_HIGH 0x04 /* __GFP_HIGH set */
778
-
#define ALLOC_CPUSET 0x08 /* check for correct cpuset */
776
+
#define ALLOC_WMARK_MIN 0x02 /* use pages_min watermark */
777
+
#define ALLOC_WMARK_LOW 0x04 /* use pages_low watermark */
778
+
#define ALLOC_WMARK_HIGH 0x08 /* use pages_high watermark */
779
+
#define ALLOC_HARDER 0x10 /* try to alloc harder */
780
+
#define ALLOC_HIGH 0x20 /* __GFP_HIGH set */
781
+
#define ALLOC_CPUSET 0x40 /* check for correct cpuset */
779
782
780
783
/*
781
784
* Return 1 if free pages are above 'mark'. This takes into account the order
···
833
830
continue;
834
831
835
832
if (!(alloc_flags & ALLOC_NO_WATERMARKS)) {
836
-
if (!zone_watermark_ok(*z, order, (*z)->pages_low,
833
+
unsigned long mark;
834
+
if (alloc_flags & ALLOC_WMARK_MIN)
835
+
mark = (*z)->pages_min;
836
+
else if (alloc_flags & ALLOC_WMARK_LOW)
837
+
mark = (*z)->pages_low;
838
+
else
839
+
mark = (*z)->pages_high;
840
+
if (!zone_watermark_ok(*z, order, mark,
837
841
classzone_idx, alloc_flags))
838
842
continue;
839
843
}
···
881
871
}
882
872
883
873
page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order,
884
-
zonelist, ALLOC_CPUSET);
874
+
zonelist, ALLOC_WMARK_LOW|ALLOC_CPUSET);
885
875
if (page)
886
876
goto got_pg;
887
877
···
898
888
* cannot run direct reclaim, or if the caller has realtime scheduling
899
889
* policy.
900
890
*/
901
-
alloc_flags = 0;
891
+
alloc_flags = ALLOC_WMARK_MIN;
902
892
if ((unlikely(rt_task(p)) && !in_interrupt()) || !wait)
903
893
alloc_flags |= ALLOC_HARDER;
904
894
if (gfp_mask & __GFP_HIGH)
···
969
959
* under heavy pressure.
970
960
*/
971
961
page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order,
972
-
zonelist, ALLOC_CPUSET);
962
+
zonelist, ALLOC_WMARK_HIGH|ALLOC_CPUSET);
973
963
if (page)
974
964
goto got_pg;
975
965
+13
-29
mm/rmap.c
+13
-29
mm/rmap.c
···
226
226
/*
227
227
* At what user virtual address is page expected in vma? checking that the
228
228
* page matches the vma: currently only used on anon pages, by unuse_vma;
229
-
* and by extraordinary checks on anon pages in VM_UNPAGED vmas, taking
230
-
* care that an mmap of /dev/mem might window free and foreign pages.
231
229
*/
232
230
unsigned long page_address_in_vma(struct page *page, struct vm_area_struct *vma)
233
231
{
···
290
292
* repeatedly from either page_referenced_anon or page_referenced_file.
291
293
*/
292
294
static int page_referenced_one(struct page *page,
293
-
struct vm_area_struct *vma, unsigned int *mapcount, int ignore_token)
295
+
struct vm_area_struct *vma, unsigned int *mapcount)
294
296
{
295
297
struct mm_struct *mm = vma->vm_mm;
296
298
unsigned long address;
···
311
313
312
314
/* Pretend the page is referenced if the task has the
313
315
swap token and is in the middle of a page fault. */
314
-
if (mm != current->mm && !ignore_token && has_swap_token(mm) &&
316
+
if (mm != current->mm && has_swap_token(mm) &&
315
317
rwsem_is_locked(&mm->mmap_sem))
316
318
referenced++;
317
319
···
321
323
return referenced;
322
324
}
323
325
324
-
static int page_referenced_anon(struct page *page, int ignore_token)
326
+
static int page_referenced_anon(struct page *page)
325
327
{
326
328
unsigned int mapcount;
327
329
struct anon_vma *anon_vma;
···
334
336
335
337
mapcount = page_mapcount(page);
336
338
list_for_each_entry(vma, &anon_vma->head, anon_vma_node) {
337
-
referenced += page_referenced_one(page, vma, &mapcount,
338
-
ignore_token);
339
+
referenced += page_referenced_one(page, vma, &mapcount);
339
340
if (!mapcount)
340
341
break;
341
342
}
···
353
356
*
354
357
* This function is only called from page_referenced for object-based pages.
355
358
*/
356
-
static int page_referenced_file(struct page *page, int ignore_token)
359
+
static int page_referenced_file(struct page *page)
357
360
{
358
361
unsigned int mapcount;
359
362
struct address_space *mapping = page->mapping;
···
391
394
referenced++;
392
395
break;
393
396
}
394
-
referenced += page_referenced_one(page, vma, &mapcount,
395
-
ignore_token);
397
+
referenced += page_referenced_one(page, vma, &mapcount);
396
398
if (!mapcount)
397
399
break;
398
400
}
···
408
412
* Quick test_and_clear_referenced for all mappings to a page,
409
413
* returns the number of ptes which referenced the page.
410
414
*/
411
-
int page_referenced(struct page *page, int is_locked, int ignore_token)
415
+
int page_referenced(struct page *page, int is_locked)
412
416
{
413
417
int referenced = 0;
414
-
415
-
if (!swap_token_default_timeout)
416
-
ignore_token = 1;
417
418
418
419
if (page_test_and_clear_young(page))
419
420
referenced++;
···
420
427
421
428
if (page_mapped(page) && page->mapping) {
422
429
if (PageAnon(page))
423
-
referenced += page_referenced_anon(page, ignore_token);
430
+
referenced += page_referenced_anon(page);
424
431
else if (is_locked)
425
-
referenced += page_referenced_file(page, ignore_token);
432
+
referenced += page_referenced_file(page);
426
433
else if (TestSetPageLocked(page))
427
434
referenced++;
428
435
else {
429
436
if (page->mapping)
430
-
referenced += page_referenced_file(page,
431
-
ignore_token);
437
+
referenced += page_referenced_file(page);
432
438
unlock_page(page);
433
439
}
434
440
}
···
606
614
struct page *page;
607
615
unsigned long address;
608
616
unsigned long end;
609
-
unsigned long pfn;
610
617
611
618
address = (vma->vm_start + cursor) & CLUSTER_MASK;
612
619
end = address + CLUSTER_SIZE;
···
634
643
for (; address < end; pte++, address += PAGE_SIZE) {
635
644
if (!pte_present(*pte))
636
645
continue;
637
-
638
-
pfn = pte_pfn(*pte);
639
-
if (unlikely(!pfn_valid(pfn))) {
640
-
print_bad_pte(vma, *pte, address);
641
-
continue;
642
-
}
643
-
644
-
page = pfn_to_page(pfn);
645
-
BUG_ON(PageAnon(page));
646
+
page = vm_normal_page(vma, address, *pte);
647
+
BUG_ON(!page || PageAnon(page));
646
648
647
649
if (ptep_clear_flush_young(vma, address, pte))
648
650
continue;
649
651
650
652
/* Nuke the page table entry. */
651
-
flush_cache_page(vma, address, pfn);
653
+
flush_cache_page(vma, address, pte_pfn(*pte));
652
654
pteval = ptep_clear_flush(vma, address, pte);
653
655
654
656
/* If nonlinear, store the file page offset in the pte. */
+7
-3
mm/thrash.c
+7
-3
mm/thrash.c
···
57
57
/* We have the token. Let others know we still need it. */
58
58
if (has_swap_token(current->mm)) {
59
59
current->mm->recent_pagein = 1;
60
+
if (unlikely(!swap_token_default_timeout))
61
+
disable_swap_token();
60
62
return;
61
63
}
62
64
63
65
if (time_after(jiffies, swap_token_check)) {
64
66
65
-
/* Can't get swapout protection if we exceed our RSS limit. */
66
-
// if (current->mm->rss > current->mm->rlimit_rss)
67
-
// return;
67
+
if (!swap_token_default_timeout) {
68
+
swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
69
+
return;
70
+
}
68
71
69
72
/* ... or if we recently held the token. */
70
73
if (time_before(jiffies, current->mm->swap_token_time))
···
98
95
{
99
96
spin_lock(&swap_token_lock);
100
97
if (likely(mm == swap_token_mm)) {
98
+
mm->swap_token_time = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
101
99
swap_token_mm = &init_mm;
102
100
swap_token_check = jiffies;
103
101
}
+24
-5
mm/vmscan.c
+24
-5
mm/vmscan.c
···
201
201
list_for_each_entry(shrinker, &shrinker_list, list) {
202
202
unsigned long long delta;
203
203
unsigned long total_scan;
204
+
unsigned long max_pass = (*shrinker->shrinker)(0, gfp_mask);
204
205
205
206
delta = (4 * scanned) / shrinker->seeks;
206
-
delta *= (*shrinker->shrinker)(0, gfp_mask);
207
+
delta *= max_pass;
207
208
do_div(delta, lru_pages + 1);
208
209
shrinker->nr += delta;
209
-
if (shrinker->nr < 0)
210
-
shrinker->nr = LONG_MAX; /* It wrapped! */
210
+
if (shrinker->nr < 0) {
211
+
printk(KERN_ERR "%s: nr=%ld\n",
212
+
__FUNCTION__, shrinker->nr);
213
+
shrinker->nr = max_pass;
214
+
}
215
+
216
+
/*
217
+
* Avoid risking looping forever due to too large nr value:
218
+
* never try to free more than twice the estimate number of
219
+
* freeable entries.
220
+
*/
221
+
if (shrinker->nr > max_pass * 2)
222
+
shrinker->nr = max_pass * 2;
211
223
212
224
total_scan = shrinker->nr;
213
225
shrinker->nr = 0;
···
419
407
if (PageWriteback(page))
420
408
goto keep_locked;
421
409
422
-
referenced = page_referenced(page, 1, sc->priority <= 0);
410
+
referenced = page_referenced(page, 1);
423
411
/* In active use or really unfreeable? Activate it. */
424
412
if (referenced && page_mapping_inuse(page))
425
413
goto activate_locked;
···
768
756
if (page_mapped(page)) {
769
757
if (!reclaim_mapped ||
770
758
(total_swap_pages == 0 && PageAnon(page)) ||
771
-
page_referenced(page, 0, sc->priority <= 0)) {
759
+
page_referenced(page, 0)) {
772
760
list_add(&page->lru, &l_active);
773
761
continue;
774
762
}
···
972
960
sc.nr_reclaimed = 0;
973
961
sc.priority = priority;
974
962
sc.swap_cluster_max = SWAP_CLUSTER_MAX;
963
+
if (!priority)
964
+
disable_swap_token();
975
965
shrink_caches(zones, &sc);
976
966
shrink_slab(sc.nr_scanned, gfp_mask, lru_pages);
977
967
if (reclaim_state) {
···
1069
1055
for (priority = DEF_PRIORITY; priority >= 0; priority--) {
1070
1056
int end_zone = 0; /* Inclusive. 0 = ZONE_DMA */
1071
1057
unsigned long lru_pages = 0;
1058
+
1059
+
/* The swap token gets in the way of swapout... */
1060
+
if (!priority)
1061
+
disable_swap_token();
1072
1062
1073
1063
all_zones_ok = 1;
1074
1064
···
1378
1360
sc.nr_reclaimed = 0;
1379
1361
/* scan at the highest priority */
1380
1362
sc.priority = 0;
1363
+
disable_swap_token();
1381
1364
1382
1365
if (nr_pages > SWAP_CLUSTER_MAX)
1383
1366
sc.swap_cluster_max = nr_pages;
+7
-4
net/atm/atm_misc.c
+7
-4
net/atm/atm_misc.c
···
74
74
*/
75
75
76
76
77
-
int atm_pcr_goal(struct atm_trafprm *tp)
77
+
int atm_pcr_goal(const struct atm_trafprm *tp)
78
78
{
79
-
if (tp->pcr && tp->pcr != ATM_MAX_PCR) return -tp->pcr;
80
-
if (tp->min_pcr && !tp->pcr) return tp->min_pcr;
81
-
if (tp->max_pcr != ATM_MAX_PCR) return -tp->max_pcr;
79
+
if (tp->pcr && tp->pcr != ATM_MAX_PCR)
80
+
return -tp->pcr;
81
+
if (tp->min_pcr && !tp->pcr)
82
+
return tp->min_pcr;
83
+
if (tp->max_pcr != ATM_MAX_PCR)
84
+
return -tp->max_pcr;
82
85
return 0;
83
86
}
84
87
+40
-26
net/atm/common.c
+40
-26
net/atm/common.c
···
221
221
EXPORT_SYMBOL(vcc_release_async);
222
222
223
223
224
+
void atm_dev_release_vccs(struct atm_dev *dev)
225
+
{
226
+
int i;
227
+
228
+
write_lock_irq(&vcc_sklist_lock);
229
+
for (i = 0; i < VCC_HTABLE_SIZE; i++) {
230
+
struct hlist_head *head = &vcc_hash[i];
231
+
struct hlist_node *node, *tmp;
232
+
struct sock *s;
233
+
struct atm_vcc *vcc;
234
+
235
+
sk_for_each_safe(s, node, tmp, head) {
236
+
vcc = atm_sk(s);
237
+
if (vcc->dev == dev) {
238
+
vcc_release_async(vcc, -EPIPE);
239
+
sk_del_node_init(s);
240
+
}
241
+
}
242
+
}
243
+
write_unlock_irq(&vcc_sklist_lock);
244
+
}
245
+
246
+
224
247
static int adjust_tp(struct atm_trafprm *tp,unsigned char aal)
225
248
{
226
249
int max_sdu;
···
355
332
return -EINVAL;
356
333
if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
357
334
return -EPERM;
358
-
error = 0;
335
+
error = -ENODEV;
359
336
if (!try_module_get(dev->ops->owner))
360
-
return -ENODEV;
337
+
return error;
361
338
vcc->dev = dev;
362
339
write_lock_irq(&vcc_sklist_lock);
363
-
if ((error = find_ci(vcc, &vpi, &vci))) {
340
+
if (test_bit(ATM_DF_REMOVED, &dev->flags) ||
341
+
(error = find_ci(vcc, &vpi, &vci))) {
364
342
write_unlock_irq(&vcc_sklist_lock);
365
343
goto fail_module_put;
366
344
}
···
447
423
if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
448
424
vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
449
425
return -EINVAL;
450
-
if (itf != ATM_ITF_ANY) {
451
-
dev = atm_dev_lookup(itf);
452
-
if (!dev)
453
-
return -ENODEV;
454
-
error = __vcc_connect(vcc, dev, vpi, vci);
455
-
if (error) {
456
-
atm_dev_put(dev);
457
-
return error;
458
-
}
426
+
if (likely(itf != ATM_ITF_ANY)) {
427
+
dev = try_then_request_module(atm_dev_lookup(itf), "atm-device-%d", itf);
459
428
} else {
460
-
struct list_head *p, *next;
461
-
462
429
dev = NULL;
463
-
spin_lock(&atm_dev_lock);
464
-
list_for_each_safe(p, next, &atm_devs) {
465
-
dev = list_entry(p, struct atm_dev, dev_list);
430
+
down(&atm_dev_mutex);
431
+
if (!list_empty(&atm_devs)) {
432
+
dev = list_entry(atm_devs.next, struct atm_dev, dev_list);
466
433
atm_dev_hold(dev);
467
-
spin_unlock(&atm_dev_lock);
468
-
if (!__vcc_connect(vcc, dev, vpi, vci))
469
-
break;
470
-
atm_dev_put(dev);
471
-
dev = NULL;
472
-
spin_lock(&atm_dev_lock);
473
434
}
474
-
spin_unlock(&atm_dev_lock);
475
-
if (!dev)
476
-
return -ENODEV;
435
+
up(&atm_dev_mutex);
436
+
}
437
+
if (!dev)
438
+
return -ENODEV;
439
+
error = __vcc_connect(vcc, dev, vpi, vci);
440
+
if (error) {
441
+
atm_dev_put(dev);
442
+
return error;
477
443
}
478
444
if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
479
445
set_bit(ATM_VF_PARTIAL,&vcc->flags);
+2
net/atm/common.h
+2
net/atm/common.h
+31
-47
net/atm/resources.c
+31
-47
net/atm/resources.c
···
25
25
26
26
27
27
LIST_HEAD(atm_devs);
28
-
DEFINE_SPINLOCK(atm_dev_lock);
28
+
DECLARE_MUTEX(atm_dev_mutex);
29
29
30
30
static struct atm_dev *__alloc_atm_dev(const char *type)
31
31
{
···
52
52
53
53
list_for_each(p, &atm_devs) {
54
54
dev = list_entry(p, struct atm_dev, dev_list);
55
-
if ((dev->ops) && (dev->number == number)) {
55
+
if (dev->number == number) {
56
56
atm_dev_hold(dev);
57
57
return dev;
58
58
}
···
64
64
{
65
65
struct atm_dev *dev;
66
66
67
-
spin_lock(&atm_dev_lock);
67
+
down(&atm_dev_mutex);
68
68
dev = __atm_dev_lookup(number);
69
-
spin_unlock(&atm_dev_lock);
69
+
up(&atm_dev_mutex);
70
70
return dev;
71
71
}
72
+
72
73
73
74
struct atm_dev *atm_dev_register(const char *type, const struct atmdev_ops *ops,
74
75
int number, unsigned long *flags)
···
82
81
type);
83
82
return NULL;
84
83
}
85
-
spin_lock(&atm_dev_lock);
84
+
down(&atm_dev_mutex);
86
85
if (number != -1) {
87
86
if ((inuse = __atm_dev_lookup(number))) {
88
87
atm_dev_put(inuse);
89
-
spin_unlock(&atm_dev_lock);
88
+
up(&atm_dev_mutex);
90
89
kfree(dev);
91
90
return NULL;
92
91
}
···
106
105
memset(&dev->flags, 0, sizeof(dev->flags));
107
106
memset(&dev->stats, 0, sizeof(dev->stats));
108
107
atomic_set(&dev->refcnt, 1);
109
-
list_add_tail(&dev->dev_list, &atm_devs);
110
-
spin_unlock(&atm_dev_lock);
111
108
112
109
if (atm_proc_dev_register(dev) < 0) {
113
110
printk(KERN_ERR "atm_dev_register: "
114
111
"atm_proc_dev_register failed for dev %s\n",
115
112
type);
116
-
spin_lock(&atm_dev_lock);
117
-
list_del(&dev->dev_list);
118
-
spin_unlock(&atm_dev_lock);
113
+
up(&atm_dev_mutex);
119
114
kfree(dev);
120
115
return NULL;
121
116
}
117
+
list_add_tail(&dev->dev_list, &atm_devs);
118
+
up(&atm_dev_mutex);
122
119
123
120
return dev;
124
121
}
···
124
125
125
126
void atm_dev_deregister(struct atm_dev *dev)
126
127
{
127
-
unsigned long warning_time;
128
+
BUG_ON(test_bit(ATM_DF_REMOVED, &dev->flags));
129
+
set_bit(ATM_DF_REMOVED, &dev->flags);
128
130
131
+
/*
132
+
* if we remove current device from atm_devs list, new device
133
+
* with same number can appear, such we need deregister proc,
134
+
* release async all vccs and remove them from vccs list too
135
+
*/
136
+
down(&atm_dev_mutex);
137
+
list_del(&dev->dev_list);
138
+
up(&atm_dev_mutex);
139
+
140
+
atm_dev_release_vccs(dev);
129
141
atm_proc_dev_deregister(dev);
130
142
131
-
spin_lock(&atm_dev_lock);
132
-
list_del(&dev->dev_list);
133
-
spin_unlock(&atm_dev_lock);
134
-
135
-
warning_time = jiffies;
136
-
while (atomic_read(&dev->refcnt) != 1) {
137
-
msleep(250);
138
-
if ((jiffies - warning_time) > 10 * HZ) {
139
-
printk(KERN_EMERG "atm_dev_deregister: waiting for "
140
-
"dev %d to become free. Usage count = %d\n",
141
-
dev->number, atomic_read(&dev->refcnt));
142
-
warning_time = jiffies;
143
-
}
144
-
}
145
-
146
-
kfree(dev);
147
-
}
148
-
149
-
void shutdown_atm_dev(struct atm_dev *dev)
150
-
{
151
-
if (atomic_read(&dev->refcnt) > 1) {
152
-
set_bit(ATM_DF_CLOSE, &dev->flags);
153
-
return;
154
-
}
155
-
if (dev->ops->dev_close)
156
-
dev->ops->dev_close(dev);
157
-
atm_dev_deregister(dev);
143
+
atm_dev_put(dev);
158
144
}
159
145
160
146
···
195
211
return -EFAULT;
196
212
if (get_user(len, &iobuf->length))
197
213
return -EFAULT;
198
-
spin_lock(&atm_dev_lock);
214
+
down(&atm_dev_mutex);
199
215
list_for_each(p, &atm_devs)
200
216
size += sizeof(int);
201
217
if (size > len) {
202
-
spin_unlock(&atm_dev_lock);
218
+
up(&atm_dev_mutex);
203
219
return -E2BIG;
204
220
}
205
221
tmp_buf = kmalloc(size, GFP_ATOMIC);
206
222
if (!tmp_buf) {
207
-
spin_unlock(&atm_dev_lock);
223
+
up(&atm_dev_mutex);
208
224
return -ENOMEM;
209
225
}
210
226
tmp_p = tmp_buf;
···
212
228
dev = list_entry(p, struct atm_dev, dev_list);
213
229
*tmp_p++ = dev->number;
214
230
}
215
-
spin_unlock(&atm_dev_lock);
231
+
up(&atm_dev_mutex);
216
232
error = ((copy_to_user(buf, tmp_buf, size)) ||
217
233
put_user(size, &iobuf->length))
218
234
? -EFAULT : 0;
···
229
245
if (get_user(number, &sioc->number))
230
246
return -EFAULT;
231
247
232
-
if (!(dev = atm_dev_lookup(number)))
248
+
if (!(dev = try_then_request_module(atm_dev_lookup(number),
249
+
"atm-device-%d", number)))
233
250
return -ENODEV;
234
251
235
252
switch (cmd) {
···
399
414
400
415
void *atm_dev_seq_start(struct seq_file *seq, loff_t *pos)
401
416
{
402
-
spin_lock(&atm_dev_lock);
417
+
down(&atm_dev_mutex);
403
418
return *pos ? dev_get_idx(*pos) : (void *) 1;
404
419
}
405
420
406
421
void atm_dev_seq_stop(struct seq_file *seq, void *v)
407
422
{
408
-
spin_unlock(&atm_dev_lock);
423
+
up(&atm_dev_mutex);
409
424
}
410
425
411
426
void *atm_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
···
419
434
EXPORT_SYMBOL(atm_dev_register);
420
435
EXPORT_SYMBOL(atm_dev_deregister);
421
436
EXPORT_SYMBOL(atm_dev_lookup);
422
-
EXPORT_SYMBOL(shutdown_atm_dev);
+1
-2
net/atm/resources.h
+1
-2
net/atm/resources.h
+1
-1
net/ipv4/fib_hash.c
+1
-1
net/ipv4/fib_hash.c
···
975
975
976
976
static unsigned fib_flag_trans(int type, u32 mask, struct fib_info *fi)
977
977
{
978
-
static unsigned type2flags[RTN_MAX + 1] = {
978
+
static const unsigned type2flags[RTN_MAX + 1] = {
979
979
[7] = RTF_REJECT, [8] = RTF_REJECT,
980
980
};
981
981
unsigned flags = type2flags[type];
+1
-1
net/ipv4/fib_semantics.c
+1
-1
net/ipv4/fib_semantics.c
+2
-2
net/ipv4/icmp.c
+2
-2
net/ipv4/icmp.c
···
220
220
short error; /* This ICMP is classed as an error message */
221
221
};
222
222
223
-
static struct icmp_control icmp_pointers[NR_ICMP_TYPES+1];
223
+
static const struct icmp_control icmp_pointers[NR_ICMP_TYPES+1];
224
224
225
225
/*
226
226
* The ICMP socket(s). This is the most convenient way to flow control
···
994
994
/*
995
995
* This table is the definition of how we handle ICMP.
996
996
*/
997
-
static struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
997
+
static const struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
998
998
[ICMP_ECHOREPLY] = {
999
999
.output_entry = ICMP_MIB_OUTECHOREPS,
1000
1000
.input_entry = ICMP_MIB_INECHOREPS,
+1
-1
net/ipv4/ip_gre.c
+1
-1
net/ipv4/ip_gre.c
···
1217
1217
return 0;
1218
1218
}
1219
1219
1220
-
int __init ipgre_fb_tunnel_init(struct net_device *dev)
1220
+
static int __init ipgre_fb_tunnel_init(struct net_device *dev)
1221
1221
{
1222
1222
struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1223
1223
struct iphdr *iph = &tunnel->parms.iph;
+1
-1
net/ipv4/ip_output.c
+1
-1
net/ipv4/ip_output.c
···
690
690
return csum;
691
691
}
692
692
693
-
inline int ip_ufo_append_data(struct sock *sk,
693
+
static inline int ip_ufo_append_data(struct sock *sk,
694
694
int getfrag(void *from, char *to, int offset, int len,
695
695
int odd, struct sk_buff *skb),
696
696
void *from, int length, int hh_len, int fragheaderlen,
+1
-1
net/ipv4/ipvs/ip_vs_conn.c
+1
-1
net/ipv4/ipvs/ip_vs_conn.c
···
771
771
* The drop rate array needs tuning for real environments.
772
772
* Called from timer bh only => no locking
773
773
*/
774
-
static char todrop_rate[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
774
+
static const char todrop_rate[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
775
775
static char todrop_counter[9] = {0};
776
776
int i;
777
777
+2
-2
net/ipv4/ipvs/ip_vs_ctl.c
+2
-2
net/ipv4/ipvs/ip_vs_ctl.c
···
1909
1909
#define DAEMON_ARG_LEN (sizeof(struct ip_vs_daemon_user))
1910
1910
#define MAX_ARG_LEN SVCDEST_ARG_LEN
1911
1911
1912
-
static unsigned char set_arglen[SET_CMDID(IP_VS_SO_SET_MAX)+1] = {
1912
+
static const unsigned char set_arglen[SET_CMDID(IP_VS_SO_SET_MAX)+1] = {
1913
1913
[SET_CMDID(IP_VS_SO_SET_ADD)] = SERVICE_ARG_LEN,
1914
1914
[SET_CMDID(IP_VS_SO_SET_EDIT)] = SERVICE_ARG_LEN,
1915
1915
[SET_CMDID(IP_VS_SO_SET_DEL)] = SERVICE_ARG_LEN,
···
2180
2180
#define GET_TIMEOUT_ARG_LEN (sizeof(struct ip_vs_timeout_user))
2181
2181
#define GET_DAEMON_ARG_LEN (sizeof(struct ip_vs_daemon_user) * 2)
2182
2182
2183
-
static unsigned char get_arglen[GET_CMDID(IP_VS_SO_GET_MAX)+1] = {
2183
+
static const unsigned char get_arglen[GET_CMDID(IP_VS_SO_GET_MAX)+1] = {
2184
2184
[GET_CMDID(IP_VS_SO_GET_VERSION)] = 64,
2185
2185
[GET_CMDID(IP_VS_SO_GET_INFO)] = GET_INFO_ARG_LEN,
2186
2186
[GET_CMDID(IP_VS_SO_GET_SERVICES)] = GET_SERVICES_ARG_LEN,
+1
-1
net/ipv4/ipvs/ip_vs_proto_tcp.c
+1
-1
net/ipv4/ipvs/ip_vs_proto_tcp.c
···
251
251
#define TCP_DIR_OUTPUT 4
252
252
#define TCP_DIR_INPUT_ONLY 8
253
253
254
-
static int tcp_state_off[IP_VS_DIR_LAST] = {
254
+
static const int tcp_state_off[IP_VS_DIR_LAST] = {
255
255
[IP_VS_DIR_INPUT] = TCP_DIR_INPUT,
256
256
[IP_VS_DIR_OUTPUT] = TCP_DIR_OUTPUT,
257
257
[IP_VS_DIR_INPUT_ONLY] = TCP_DIR_INPUT_ONLY,
+1
-1
net/ipv4/netfilter/ip_conntrack_amanda.c
+1
-1
net/ipv4/netfilter/ip_conntrack_amanda.c
···
37
37
module_param(master_timeout, int, 0600);
38
38
MODULE_PARM_DESC(master_timeout, "timeout for the master connection");
39
39
40
-
static char *conns[] = { "DATA ", "MESG ", "INDEX " };
40
+
static const char *conns[] = { "DATA ", "MESG ", "INDEX " };
41
41
42
42
/* This is slow, but it's simple. --RR */
43
43
static char *amanda_buffer;
+2
-2
net/ipv4/netfilter/ip_conntrack_core.c
+2
-2
net/ipv4/netfilter/ip_conntrack_core.c
···
1354
1354
get_order(sizeof(struct list_head) * size));
1355
1355
}
1356
1356
1357
-
void ip_conntrack_flush()
1357
+
void ip_conntrack_flush(void)
1358
1358
{
1359
1359
/* This makes sure all current packets have passed through
1360
1360
netfilter framework. Roll on, two-stage module
···
1408
1408
return hash;
1409
1409
}
1410
1410
1411
-
int set_hashsize(const char *val, struct kernel_param *kp)
1411
+
static int set_hashsize(const char *val, struct kernel_param *kp)
1412
1412
{
1413
1413
int i, bucket, hashsize, vmalloced;
1414
1414
int old_vmalloced, old_size;
+1
-1
net/ipv4/netfilter/ip_conntrack_ftp.c
+1
-1
net/ipv4/netfilter/ip_conntrack_ftp.c
···
55
55
static int try_eprt(const char *, size_t, u_int32_t [], char);
56
56
static int try_epsv_response(const char *, size_t, u_int32_t [], char);
57
57
58
-
static struct ftp_search {
58
+
static const struct ftp_search {
59
59
enum ip_conntrack_dir dir;
60
60
const char *pattern;
61
61
size_t plen;
+1
-1
net/ipv4/netfilter/ip_conntrack_irc.c
+1
-1
net/ipv4/netfilter/ip_conntrack_irc.c
···
59
59
module_param(dcc_timeout, int, 0400);
60
60
MODULE_PARM_DESC(dcc_timeout, "timeout on for unestablished DCC channels");
61
61
62
-
static char *dccprotos[] = { "SEND ", "CHAT ", "MOVE ", "TSEND ", "SCHAT " };
62
+
static const char *dccprotos[] = { "SEND ", "CHAT ", "MOVE ", "TSEND ", "SCHAT " };
63
63
#define MINMATCHLEN 5
64
64
65
65
#if 0
+2
-2
net/ipv4/netfilter/ip_conntrack_proto_icmp.c
+2
-2
net/ipv4/netfilter/ip_conntrack_proto_icmp.c
···
51
51
const struct ip_conntrack_tuple *orig)
52
52
{
53
53
/* Add 1; spaces filled with 0. */
54
-
static u_int8_t invmap[]
54
+
static const u_int8_t invmap[]
55
55
= { [ICMP_ECHO] = ICMP_ECHOREPLY + 1,
56
56
[ICMP_ECHOREPLY] = ICMP_ECHO + 1,
57
57
[ICMP_TIMESTAMP] = ICMP_TIMESTAMPREPLY + 1,
···
110
110
return NF_ACCEPT;
111
111
}
112
112
113
-
static u_int8_t valid_new[] = {
113
+
static const u_int8_t valid_new[] = {
114
114
[ICMP_ECHO] = 1,
115
115
[ICMP_TIMESTAMP] = 1,
116
116
[ICMP_INFO_REQUEST] = 1,
+2
-2
net/ipv4/netfilter/ip_conntrack_proto_sctp.c
+2
-2
net/ipv4/netfilter/ip_conntrack_proto_sctp.c
···
65
65
static unsigned long ip_ct_sctp_timeout_shutdown_recd = 300 SECS / 1000;
66
66
static unsigned long ip_ct_sctp_timeout_shutdown_ack_sent = 3 SECS;
67
67
68
-
static unsigned long * sctp_timeouts[]
68
+
static const unsigned long * sctp_timeouts[]
69
69
= { NULL, /* SCTP_CONNTRACK_NONE */
70
70
&ip_ct_sctp_timeout_closed, /* SCTP_CONNTRACK_CLOSED */
71
71
&ip_ct_sctp_timeout_cookie_wait, /* SCTP_CONNTRACK_COOKIE_WAIT */
···
118
118
*/
119
119
120
120
/* SCTP conntrack state transitions */
121
-
static enum sctp_conntrack sctp_conntracks[2][9][SCTP_CONNTRACK_MAX] = {
121
+
static const enum sctp_conntrack sctp_conntracks[2][9][SCTP_CONNTRACK_MAX] = {
122
122
{
123
123
/* ORIGINAL */
124
124
/* sNO, sCL, sCW, sCE, sES, sSS, sSR, sSA */
+3
-3
net/ipv4/netfilter/ip_conntrack_proto_tcp.c
+3
-3
net/ipv4/netfilter/ip_conntrack_proto_tcp.c
···
99
99
to ~13-30min depending on RTO. */
100
100
unsigned long ip_ct_tcp_timeout_max_retrans = 5 MINS;
101
101
102
-
static unsigned long * tcp_timeouts[]
102
+
static const unsigned long * tcp_timeouts[]
103
103
= { NULL, /* TCP_CONNTRACK_NONE */
104
104
&ip_ct_tcp_timeout_syn_sent, /* TCP_CONNTRACK_SYN_SENT, */
105
105
&ip_ct_tcp_timeout_syn_recv, /* TCP_CONNTRACK_SYN_RECV, */
···
170
170
* if they are invalid
171
171
* or we do not support the request (simultaneous open)
172
172
*/
173
-
static enum tcp_conntrack tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
173
+
static const enum tcp_conntrack tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
174
174
{
175
175
/* ORIGINAL */
176
176
/* sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI */
···
817
817
#define TH_CWR 0x80
818
818
819
819
/* table of valid flag combinations - ECE and CWR are always valid */
820
-
static u8 tcp_valid_flags[(TH_FIN|TH_SYN|TH_RST|TH_PUSH|TH_ACK|TH_URG) + 1] =
820
+
static const u8 tcp_valid_flags[(TH_FIN|TH_SYN|TH_RST|TH_PUSH|TH_ACK|TH_URG) + 1] =
821
821
{
822
822
[TH_SYN] = 1,
823
823
[TH_SYN|TH_ACK] = 1,
+1
-1
net/ipv4/netfilter/ip_nat_core.c
+1
-1
net/ipv4/netfilter/ip_nat_core.c
···
49
49
static struct list_head *bysource;
50
50
51
51
#define MAX_IP_NAT_PROTO 256
52
-
struct ip_nat_protocol *ip_nat_protos[MAX_IP_NAT_PROTO];
52
+
static struct ip_nat_protocol *ip_nat_protos[MAX_IP_NAT_PROTO];
53
53
54
54
static inline struct ip_nat_protocol *
55
55
__ip_nat_proto_find(u_int8_t protonum)
+1
-1
net/ipv4/netfilter/ip_tables.c
+1
-1
net/ipv4/netfilter/ip_tables.c
···
1892
1892
return pos;
1893
1893
}
1894
1894
1895
-
static struct { char *name; get_info_t *get_info; } ipt_proc_entry[] =
1895
+
static const struct { char *name; get_info_t *get_info; } ipt_proc_entry[] =
1896
1896
{ { "ip_tables_names", ipt_get_tables },
1897
1897
{ "ip_tables_targets", ipt_get_targets },
1898
1898
{ "ip_tables_matches", ipt_get_matches },
+2
-2
net/ipv4/netfilter/ipt_LOG.c
+2
-2
net/ipv4/netfilter/ipt_LOG.c
···
197
197
}
198
198
case IPPROTO_ICMP: {
199
199
struct icmphdr _icmph, *ich;
200
-
static size_t required_len[NR_ICMP_TYPES+1]
200
+
static const size_t required_len[NR_ICMP_TYPES+1]
201
201
= { [ICMP_ECHOREPLY] = 4,
202
202
[ICMP_DEST_UNREACH]
203
203
= 8 + sizeof(struct iphdr),
···
351
351
/* maxlen = 230+ 91 + 230 + 252 = 803 */
352
352
}
353
353
354
-
struct nf_loginfo default_loginfo = {
354
+
static struct nf_loginfo default_loginfo = {
355
355
.type = NF_LOG_TYPE_LOG,
356
356
.u = {
357
357
.log = {
+5
-5
net/ipv4/proc.c
+5
-5
net/ipv4/proc.c
···
98
98
}
99
99
100
100
/* snmp items */
101
-
static struct snmp_mib snmp4_ipstats_list[] = {
101
+
static const struct snmp_mib snmp4_ipstats_list[] = {
102
102
SNMP_MIB_ITEM("InReceives", IPSTATS_MIB_INRECEIVES),
103
103
SNMP_MIB_ITEM("InHdrErrors", IPSTATS_MIB_INHDRERRORS),
104
104
SNMP_MIB_ITEM("InAddrErrors", IPSTATS_MIB_INADDRERRORS),
···
119
119
SNMP_MIB_SENTINEL
120
120
};
121
121
122
-
static struct snmp_mib snmp4_icmp_list[] = {
122
+
static const struct snmp_mib snmp4_icmp_list[] = {
123
123
SNMP_MIB_ITEM("InMsgs", ICMP_MIB_INMSGS),
124
124
SNMP_MIB_ITEM("InErrors", ICMP_MIB_INERRORS),
125
125
SNMP_MIB_ITEM("InDestUnreachs", ICMP_MIB_INDESTUNREACHS),
···
149
149
SNMP_MIB_SENTINEL
150
150
};
151
151
152
-
static struct snmp_mib snmp4_tcp_list[] = {
152
+
static const struct snmp_mib snmp4_tcp_list[] = {
153
153
SNMP_MIB_ITEM("RtoAlgorithm", TCP_MIB_RTOALGORITHM),
154
154
SNMP_MIB_ITEM("RtoMin", TCP_MIB_RTOMIN),
155
155
SNMP_MIB_ITEM("RtoMax", TCP_MIB_RTOMAX),
···
167
167
SNMP_MIB_SENTINEL
168
168
};
169
169
170
-
static struct snmp_mib snmp4_udp_list[] = {
170
+
static const struct snmp_mib snmp4_udp_list[] = {
171
171
SNMP_MIB_ITEM("InDatagrams", UDP_MIB_INDATAGRAMS),
172
172
SNMP_MIB_ITEM("NoPorts", UDP_MIB_NOPORTS),
173
173
SNMP_MIB_ITEM("InErrors", UDP_MIB_INERRORS),
···
175
175
SNMP_MIB_SENTINEL
176
176
};
177
177
178
-
static struct snmp_mib snmp4_net_list[] = {
178
+
static const struct snmp_mib snmp4_net_list[] = {
179
179
SNMP_MIB_ITEM("SyncookiesSent", LINUX_MIB_SYNCOOKIESSENT),
180
180
SNMP_MIB_ITEM("SyncookiesRecv", LINUX_MIB_SYNCOOKIESRECV),
181
181
SNMP_MIB_ITEM("SyncookiesFailed", LINUX_MIB_SYNCOOKIESFAILED),
+2
-3
net/ipv4/route.c
+2
-3
net/ipv4/route.c
···
1371
1371
* are needed for AMPRnet AX.25 paths.
1372
1372
*/
1373
1373
1374
-
static unsigned short mtu_plateau[] =
1374
+
static const unsigned short mtu_plateau[] =
1375
1375
{32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };
1376
1376
1377
1377
static __inline__ unsigned short guess_mtu(unsigned short old_mtu)
···
3149
3149
sizeof(struct rt_hash_bucket),
3150
3150
rhash_entries,
3151
3151
(num_physpages >= 128 * 1024) ?
3152
-
(27 - PAGE_SHIFT) :
3153
-
(29 - PAGE_SHIFT),
3152
+
15 : 17,
3154
3153
HASH_HIGHMEM,
3155
3154
&rt_hash_log,
3156
3155
&rt_hash_mask,
+3
-5
net/ipv4/tcp.c
+3
-5
net/ipv4/tcp.c
···
1413
1413
* closed.
1414
1414
*/
1415
1415
1416
-
static unsigned char new_state[16] = {
1416
+
static const unsigned char new_state[16] = {
1417
1417
/* current state: new state: action: */
1418
1418
/* (Invalid) */ TCP_CLOSE,
1419
1419
/* TCP_ESTABLISHED */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
···
2065
2065
sizeof(struct inet_ehash_bucket),
2066
2066
thash_entries,
2067
2067
(num_physpages >= 128 * 1024) ?
2068
-
(25 - PAGE_SHIFT) :
2069
-
(27 - PAGE_SHIFT),
2068
+
13 : 15,
2070
2069
HASH_HIGHMEM,
2071
2070
&tcp_hashinfo.ehash_size,
2072
2071
NULL,
···
2081
2082
sizeof(struct inet_bind_hashbucket),
2082
2083
tcp_hashinfo.ehash_size,
2083
2084
(num_physpages >= 128 * 1024) ?
2084
-
(25 - PAGE_SHIFT) :
2085
-
(27 - PAGE_SHIFT),
2085
+
13 : 15,
2086
2086
HASH_HIGHMEM,
2087
2087
&tcp_hashinfo.bhash_size,
2088
2088
NULL,
+2
net/ipv6/addrconf.c
+2
net/ipv6/addrconf.c
+1
-1
net/ipv6/icmp.c
+1
-1
net/ipv6/icmp.c
+2
-1
net/ipv6/ip6_output.c
+2
-1
net/ipv6/ip6_output.c
···
774
774
*dst = NULL;
775
775
return err;
776
776
}
777
-
inline int ip6_ufo_append_data(struct sock *sk,
777
+
778
+
static inline int ip6_ufo_append_data(struct sock *sk,
778
779
int getfrag(void *from, char *to, int offset, int len,
779
780
int odd, struct sk_buff *skb),
780
781
void *from, int length, int hh_len, int fragheaderlen,
+2
-2
net/ipv6/ipv6_sockglue.c
+2
-2
net/ipv6/ipv6_sockglue.c
···
628
628
return -EINVAL;
629
629
}
630
630
631
-
int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_opt_hdr *hdr,
632
-
char __user *optval, int len)
631
+
static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_opt_hdr *hdr,
632
+
char __user *optval, int len)
633
633
{
634
634
if (!hdr)
635
635
return 0;
+1
-1
net/ipv6/netfilter/ip6_tables.c
+1
-1
net/ipv6/netfilter/ip6_tables.c
···
1972
1972
return pos;
1973
1973
}
1974
1974
1975
-
static struct { char *name; get_info_t *get_info; } ip6t_proc_entry[] =
1975
+
static const struct { char *name; get_info_t *get_info; } ip6t_proc_entry[] =
1976
1976
{ { "ip6_tables_names", ip6t_get_tables },
1977
1977
{ "ip6_tables_targets", ip6t_get_targets },
1978
1978
{ "ip6_tables_matches", ip6t_get_matches },