Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6

* 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6:
[IA64] Convert ia64 to use int-ll64.h
[IA64] Fix build error in paravirt_patchlist.c
[IA64] ia64 does not need umount2() syscall
[IA64] hook up new rt_tgsigqueueinfo syscall
[IA64] msi_ia64.c dmar_msi_type should be static
[IA64] remove obsolete hw_interrupt_type
[IA64] remove obsolete irq_desc_t typedef
[IA64] remove obsolete no_irq_type
[IA64] unexport fpswa.h

+238 -231
+1 -1
arch/ia64/hp/common/sba_iommu.c
··· 1787 1787 }; 1788 1788 1789 1789 static struct ioc * __init 1790 - ioc_init(u64 hpa, void *handle) 1790 + ioc_init(unsigned long hpa, void *handle) 1791 1791 { 1792 1792 struct ioc *ioc; 1793 1793 struct ioc_iommu *info;
+3 -3
arch/ia64/hp/sim/hpsim_irq.c
··· 27 27 return 0; 28 28 } 29 29 30 - static struct hw_interrupt_type irq_type_hp_sim = { 30 + static struct irq_chip irq_type_hp_sim = { 31 31 .name = "hpsim", 32 32 .startup = hpsim_irq_startup, 33 33 .shutdown = hpsim_irq_noop, ··· 41 41 void __init 42 42 hpsim_irq_init (void) 43 43 { 44 - irq_desc_t *idesc; 44 + struct irq_desc *idesc; 45 45 int i; 46 46 47 47 for (i = 0; i < NR_IRQS; ++i) { 48 48 idesc = irq_desc + i; 49 - if (idesc->chip == &no_irq_type) 49 + if (idesc->chip == &no_irq_chip) 50 50 idesc->chip = &irq_type_hp_sim; 51 51 } 52 52 }
-1
arch/ia64/include/asm/Kbuild
··· 2 2 3 3 header-y += break.h 4 4 header-y += fpu.h 5 - header-y += fpswa.h 6 5 header-y += ia64regs.h 7 6 header-y += intel_intrin.h 8 7 header-y += perfmon_default_smpl.h
+9 -9
arch/ia64/include/asm/gcc_intrin.h
··· 388 388 389 389 #define ia64_native_thash(addr) \ 390 390 ({ \ 391 - __u64 ia64_intri_res; \ 391 + unsigned long ia64_intri_res; \ 392 392 asm volatile ("thash %0=%1" : "=r"(ia64_intri_res) : "r" (addr)); \ 393 393 ia64_intri_res; \ 394 394 }) ··· 419 419 420 420 #define ia64_tpa(addr) \ 421 421 ({ \ 422 - __u64 ia64_pa; \ 422 + unsigned long ia64_pa; \ 423 423 asm volatile ("tpa %0 = %1" : "=r"(ia64_pa) : "r"(addr) : "memory"); \ 424 424 ia64_pa; \ 425 425 }) ··· 444 444 445 445 #define ia64_native_get_cpuid(index) \ 446 446 ({ \ 447 - __u64 ia64_intri_res; \ 447 + unsigned long ia64_intri_res; \ 448 448 asm volatile ("mov %0=cpuid[%r1]" : "=r"(ia64_intri_res) : "rO"(index)); \ 449 449 ia64_intri_res; \ 450 450 }) 451 451 452 452 #define __ia64_get_dbr(index) \ 453 453 ({ \ 454 - __u64 ia64_intri_res; \ 454 + unsigned long ia64_intri_res; \ 455 455 asm volatile ("mov %0=dbr[%1]" : "=r"(ia64_intri_res) : "r"(index)); \ 456 456 ia64_intri_res; \ 457 457 }) 458 458 459 459 #define ia64_get_ibr(index) \ 460 460 ({ \ 461 - __u64 ia64_intri_res; \ 461 + unsigned long ia64_intri_res; \ 462 462 asm volatile ("mov %0=ibr[%1]" : "=r"(ia64_intri_res) : "r"(index)); \ 463 463 ia64_intri_res; \ 464 464 }) 465 465 466 466 #define ia64_get_pkr(index) \ 467 467 ({ \ 468 - __u64 ia64_intri_res; \ 468 + unsigned long ia64_intri_res; \ 469 469 asm volatile ("mov %0=pkr[%1]" : "=r"(ia64_intri_res) : "r"(index)); \ 470 470 ia64_intri_res; \ 471 471 }) 472 472 473 473 #define ia64_get_pmc(index) \ 474 474 ({ \ 475 - __u64 ia64_intri_res; \ 475 + unsigned long ia64_intri_res; \ 476 476 asm volatile ("mov %0=pmc[%1]" : "=r"(ia64_intri_res) : "r"(index)); \ 477 477 ia64_intri_res; \ 478 478 }) ··· 480 480 481 481 #define ia64_native_get_pmd(index) \ 482 482 ({ \ 483 - __u64 ia64_intri_res; \ 483 + unsigned long ia64_intri_res; \ 484 484 asm volatile ("mov %0=pmd[%1]" : "=r"(ia64_intri_res) : "r"(index)); \ 485 485 ia64_intri_res; \ 486 486 }) 487 487 488 488 #define ia64_native_get_rr(index) \ 489 489 ({ \ 490 - __u64 ia64_intri_res; \ 490 + unsigned long ia64_intri_res; \ 491 491 asm volatile ("mov %0=rr[%1]" : "=r"(ia64_intri_res) : "r" (index)); \ 492 492 ia64_intri_res; \ 493 493 })
+2 -2
arch/ia64/include/asm/hw_irq.h
··· 106 106 #define irq_to_domain(x) irq_cfg[(x)].domain 107 107 DECLARE_PER_CPU(int[IA64_NUM_VECTORS], vector_irq); 108 108 109 - extern struct hw_interrupt_type irq_type_ia64_lsapic; /* CPU-internal interrupt controller */ 109 + extern struct irq_chip irq_type_ia64_lsapic; /* CPU-internal interrupt controller */ 110 110 111 111 #ifdef CONFIG_PARAVIRT_GUEST 112 112 #include <asm/paravirt.h> ··· 146 146 * Default implementations for the irq-descriptor API: 147 147 */ 148 148 149 - extern irq_desc_t irq_desc[NR_IRQS]; 149 + extern struct irq_desc irq_desc[NR_IRQS]; 150 150 151 151 #ifndef CONFIG_IA64_GENERIC 152 152 static inline ia64_vector __ia64_irq_to_vector(int irq)
+19 -19
arch/ia64/include/asm/mca.h
··· 72 72 struct ia64_sal_os_state { 73 73 74 74 /* SAL to OS */ 75 - u64 os_gp; /* GP of the os registered with the SAL, physical */ 76 - u64 pal_proc; /* PAL_PROC entry point, physical */ 77 - u64 sal_proc; /* SAL_PROC entry point, physical */ 78 - u64 rv_rc; /* MCA - Rendezvous state, INIT - reason code */ 79 - u64 proc_state_param; /* from R18 */ 80 - u64 monarch; /* 1 for a monarch event, 0 for a slave */ 75 + unsigned long os_gp; /* GP of the os registered with the SAL, physical */ 76 + unsigned long pal_proc; /* PAL_PROC entry point, physical */ 77 + unsigned long sal_proc; /* SAL_PROC entry point, physical */ 78 + unsigned long rv_rc; /* MCA - Rendezvous state, INIT - reason code */ 79 + unsigned long proc_state_param; /* from R18 */ 80 + unsigned long monarch; /* 1 for a monarch event, 0 for a slave */ 81 81 82 82 /* common */ 83 - u64 sal_ra; /* Return address in SAL, physical */ 84 - u64 sal_gp; /* GP of the SAL - physical */ 83 + unsigned long sal_ra; /* Return address in SAL, physical */ 84 + unsigned long sal_gp; /* GP of the SAL - physical */ 85 85 pal_min_state_area_t *pal_min_state; /* from R17. physical in asm, virtual in C */ 86 86 /* Previous values of IA64_KR(CURRENT) and IA64_KR(CURRENT_STACK). 87 87 * Note: if the MCA/INIT recovery code wants to resume to a new context 88 88 * then it must change these values to reflect the new kernel stack. 89 89 */ 90 - u64 prev_IA64_KR_CURRENT; /* previous value of IA64_KR(CURRENT) */ 91 - u64 prev_IA64_KR_CURRENT_STACK; 90 + unsigned long prev_IA64_KR_CURRENT; /* previous value of IA64_KR(CURRENT) */ 91 + unsigned long prev_IA64_KR_CURRENT_STACK; 92 92 struct task_struct *prev_task; /* previous task, NULL if it is not useful */ 93 93 /* Some interrupt registers are not saved in minstate, pt_regs or 94 94 * switch_stack. Because MCA/INIT can occur when interrupts are 95 95 * disabled, we need to save the additional interrupt registers over 96 96 * MCA/INIT and resume. 97 97 */ 98 - u64 isr; 99 - u64 ifa; 100 - u64 itir; 101 - u64 iipa; 102 - u64 iim; 103 - u64 iha; 98 + unsigned long isr; 99 + unsigned long ifa; 100 + unsigned long itir; 101 + unsigned long iipa; 102 + unsigned long iim; 103 + unsigned long iha; 104 104 105 105 /* OS to SAL */ 106 - u64 os_status; /* OS status to SAL, enum below */ 107 - u64 context; /* 0 if return to same context 106 + unsigned long os_status; /* OS status to SAL, enum below */ 107 + unsigned long context; /* 0 if return to same context 108 108 1 if return to new context */ 109 109 }; 110 110 ··· 150 150 extern void ia64_mca_cmc_vector_setup(void); 151 151 extern int ia64_reg_MCA_extension(int (*fn)(void *, struct ia64_sal_os_state *)); 152 152 extern void ia64_unreg_MCA_extension(void); 153 - extern u64 ia64_get_rnat(u64 *); 153 + extern unsigned long ia64_get_rnat(unsigned long *); 154 154 extern void ia64_mca_printk(const char * fmt, ...) 155 155 __attribute__ ((format (printf, 1, 2))); 156 156
+9 -9
arch/ia64/include/asm/meminit.h
··· 25 25 #define IA64_MAX_RSVD_REGIONS 9 26 26 27 27 struct rsvd_region { 28 - unsigned long start; /* virtual address of beginning of element */ 29 - unsigned long end; /* virtual address of end of element + 1 */ 28 + u64 start; /* virtual address of beginning of element */ 29 + u64 end; /* virtual address of end of element + 1 */ 30 30 }; 31 31 32 32 extern struct rsvd_region rsvd_region[IA64_MAX_RSVD_REGIONS + 1]; ··· 35 35 extern void find_memory (void); 36 36 extern void reserve_memory (void); 37 37 extern void find_initrd (void); 38 - extern int filter_rsvd_memory (unsigned long start, unsigned long end, void *arg); 39 - extern int filter_memory (unsigned long start, unsigned long end, void *arg); 40 - extern unsigned long efi_memmap_init(unsigned long *s, unsigned long *e); 41 - extern int find_max_min_low_pfn (unsigned long , unsigned long, void *); 38 + extern int filter_rsvd_memory (u64 start, u64 end, void *arg); 39 + extern int filter_memory (u64 start, u64 end, void *arg); 40 + extern unsigned long efi_memmap_init(u64 *s, u64 *e); 41 + extern int find_max_min_low_pfn (u64, u64, void *); 42 42 43 43 extern unsigned long vmcore_find_descriptor_size(unsigned long address); 44 - extern int reserve_elfcorehdr(unsigned long *start, unsigned long *end); 44 + extern int reserve_elfcorehdr(u64 *start, u64 *end); 45 45 46 46 /* 47 47 * For rounding an address to the next IA64_GRANULE_SIZE or order ··· 63 63 # define LARGE_GAP 0x40000000 /* Use virtual mem map if hole is > than this */ 64 64 extern unsigned long vmalloc_end; 65 65 extern struct page *vmem_map; 66 - extern int find_largest_hole (u64 start, u64 end, void *arg); 67 - extern int create_mem_map_page_table (u64 start, u64 end, void *arg); 66 + extern int find_largest_hole(u64 start, u64 end, void *arg); 67 + extern int create_mem_map_page_table(u64 start, u64 end, void *arg); 68 68 extern int vmemmap_find_next_valid_pfn(int, int); 69 69 #else 70 70 static inline int vmemmap_find_next_valid_pfn(int node, int i)
+11 -13
arch/ia64/include/asm/pal.h
··· 989 989 } 990 990 991 991 /* Return summary information about the hierarchy of caches controlled by the processor */ 992 - static inline s64 993 - ia64_pal_cache_summary (u64 *cache_levels, u64 *unique_caches) 992 + static inline long ia64_pal_cache_summary(unsigned long *cache_levels, 993 + unsigned long *unique_caches) 994 994 { 995 995 struct ia64_pal_retval iprv; 996 996 PAL_CALL(iprv, PAL_CACHE_SUMMARY, 0, 0, 0); ··· 1038 1038 } 1039 1039 1040 1040 /* Return the number of instruction and data debug register pairs */ 1041 - static inline s64 1042 - ia64_pal_debug_info (u64 *inst_regs, u64 *data_regs) 1041 + static inline long ia64_pal_debug_info(unsigned long *inst_regs, 1042 + unsigned long *data_regs) 1043 1043 { 1044 1044 struct ia64_pal_retval iprv; 1045 1045 PAL_CALL(iprv, PAL_DEBUG_INFO, 0, 0, 0); ··· 1074 1074 } 1075 1075 1076 1076 /* Get base frequency of the platform if generated by the processor */ 1077 - static inline s64 1078 - ia64_pal_freq_base (u64 *platform_base_freq) 1077 + static inline long ia64_pal_freq_base(unsigned long *platform_base_freq) 1079 1078 { 1080 1079 struct ia64_pal_retval iprv; 1081 1080 PAL_CALL(iprv, PAL_FREQ_BASE, 0, 0, 0); ··· 1436 1437 * possible. 1437 1438 */ 1438 1439 typedef struct ia64_ptce_info_s { 1439 - u64 base; 1440 + unsigned long base; 1440 1441 u32 count[2]; 1441 1442 u32 stride[2]; 1442 1443 } ia64_ptce_info_t; ··· 1477 1478 } 1478 1479 1479 1480 typedef union pal_hints_u { 1480 - u64 ph_data; 1481 + unsigned long ph_data; 1481 1482 struct { 1482 - u64 si : 1, 1483 + unsigned long si : 1, 1483 1484 li : 1, 1484 1485 reserved : 62; 1485 1486 } pal_hints_s; ··· 1488 1489 /* Return information about the register stack and RSE for this processor 1489 1490 * implementation. 1490 1491 */ 1491 - static inline s64 1492 - ia64_pal_rse_info (u64 *num_phys_stacked, pal_hints_u_t *hints) 1492 + static inline long ia64_pal_rse_info(unsigned long *num_phys_stacked, 1493 + pal_hints_u_t *hints) 1493 1494 { 1494 1495 struct ia64_pal_retval iprv; 1495 1496 PAL_CALL(iprv, PAL_RSE_INFO, 0, 0, 0); ··· 1607 1608 /* Get page size information about the virtual memory characteristics of the processor 1608 1609 * implementation. 1609 1610 */ 1610 - static inline s64 1611 - ia64_pal_vm_page_size (u64 *tr_pages, u64 *vw_pages) 1611 + static inline s64 ia64_pal_vm_page_size(u64 *tr_pages, u64 *vw_pages) 1612 1612 { 1613 1613 struct ia64_pal_retval iprv; 1614 1614 PAL_CALL(iprv, PAL_VM_PAGE_SIZE, 0, 0, 0);
+28 -28
arch/ia64/include/asm/processor.h
··· 187 187 * state comes earlier: 188 188 */ 189 189 struct cpuinfo_ia64 { 190 - __u32 softirq_pending; 191 - __u64 itm_delta; /* # of clock cycles between clock ticks */ 192 - __u64 itm_next; /* interval timer mask value to use for next clock tick */ 193 - __u64 nsec_per_cyc; /* (1000000000<<IA64_NSEC_PER_CYC_SHIFT)/itc_freq */ 194 - __u64 unimpl_va_mask; /* mask of unimplemented virtual address bits (from PAL) */ 195 - __u64 unimpl_pa_mask; /* mask of unimplemented physical address bits (from PAL) */ 196 - __u64 itc_freq; /* frequency of ITC counter */ 197 - __u64 proc_freq; /* frequency of processor */ 198 - __u64 cyc_per_usec; /* itc_freq/1000000 */ 199 - __u64 ptce_base; 200 - __u32 ptce_count[2]; 201 - __u32 ptce_stride[2]; 190 + unsigned int softirq_pending; 191 + unsigned long itm_delta; /* # of clock cycles between clock ticks */ 192 + unsigned long itm_next; /* interval timer mask value to use for next clock tick */ 193 + unsigned long nsec_per_cyc; /* (1000000000<<IA64_NSEC_PER_CYC_SHIFT)/itc_freq */ 194 + unsigned long unimpl_va_mask; /* mask of unimplemented virtual address bits (from PAL) */ 195 + unsigned long unimpl_pa_mask; /* mask of unimplemented physical address bits (from PAL) */ 196 + unsigned long itc_freq; /* frequency of ITC counter */ 197 + unsigned long proc_freq; /* frequency of processor */ 198 + unsigned long cyc_per_usec; /* itc_freq/1000000 */ 199 + unsigned long ptce_base; 200 + unsigned int ptce_count[2]; 201 + unsigned int ptce_stride[2]; 202 202 struct task_struct *ksoftirqd; /* kernel softirq daemon for this CPU */ 203 203 204 204 #ifdef CONFIG_SMP 205 - __u64 loops_per_jiffy; 205 + unsigned long loops_per_jiffy; 206 206 int cpu; 207 - __u32 socket_id; /* physical processor socket id */ 208 - __u16 core_id; /* core id */ 209 - __u16 thread_id; /* thread id */ 210 - __u16 num_log; /* Total number of logical processors on 207 + unsigned int socket_id; /* physical processor socket id */ 208 + unsigned short core_id; /* core id */ 209 + unsigned short thread_id; /* thread id */ 210 + unsigned short num_log; /* Total number of logical processors on 211 211 * this socket that were successfully booted */ 212 - __u8 cores_per_socket; /* Cores per processor socket */ 213 - __u8 threads_per_core; /* Threads per core */ 212 + unsigned char cores_per_socket; /* Cores per processor socket */ 213 + unsigned char threads_per_core; /* Threads per core */ 214 214 #endif 215 215 216 216 /* CPUID-derived information: */ 217 - __u64 ppn; 218 - __u64 features; 219 - __u8 number; 220 - __u8 revision; 221 - __u8 model; 222 - __u8 family; 223 - __u8 archrev; 217 + unsigned long ppn; 218 + unsigned long features; 219 + unsigned char number; 220 + unsigned char revision; 221 + unsigned char model; 222 + unsigned char family; 223 + unsigned char archrev; 224 224 char vendor[16]; 225 225 char *model_name; 226 226 ··· 329 329 #else 330 330 # define INIT_THREAD_PM 331 331 #endif 332 - __u64 dbr[IA64_NUM_DBG_REGS]; 333 - __u64 ibr[IA64_NUM_DBG_REGS]; 332 + unsigned long dbr[IA64_NUM_DBG_REGS]; 333 + unsigned long ibr[IA64_NUM_DBG_REGS]; 334 334 struct ia64_fpreg fph[96]; /* saved/loaded on demand */ 335 335 }; 336 336
+4 -4
arch/ia64/include/asm/sal.h
··· 106 106 * informational value should be printed (e.g., "reboot for 107 107 * change to take effect"). 108 108 */ 109 - s64 status; 110 - u64 v0; 111 - u64 v1; 112 - u64 v2; 109 + long status; 110 + unsigned long v0; 111 + unsigned long v1; 112 + unsigned long v2; 113 113 }; 114 114 115 115 typedef struct ia64_sal_retval (*ia64_sal_handler) (u64, ...);
+1 -1
arch/ia64/include/asm/sn/sn_sal.h
··· 929 929 /* 930 930 * Get the associated ioboard type for a given nasid. 931 931 */ 932 - static inline s64 932 + static inline long 933 933 ia64_sn_sysctl_ioboard_get(nasid_t nasid, u16 *ioboard) 934 934 { 935 935 struct ia64_sal_retval isrv;
+9 -4
arch/ia64/include/asm/types.h
··· 2 2 #define _ASM_IA64_TYPES_H 3 3 4 4 /* 5 - * This file is never included by application software unless explicitly requested (e.g., 6 - * via linux/types.h) in which case the application is Linux specific so (user-) name 7 - * space pollution is not a major issue. However, for interoperability, libraries still 8 - * need to be careful to avoid a name clashes. 5 + * This file is never included by application software unless explicitly 6 + * requested (e.g., via linux/types.h) in which case the application is 7 + * Linux specific so (user-) name space pollution is not a major issue. 8 + * However, for interoperability, libraries still need to be careful to 9 + * avoid naming clashes. 9 10 * 10 11 * Based on <asm-alpha/types.h>. 11 12 * ··· 14 13 * David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co 15 14 */ 16 15 16 + #ifdef __KERNEL__ 17 + #include <asm-generic/int-ll64.h> 18 + #else 17 19 #include <asm-generic/int-l64.h> 20 + #endif 18 21 19 22 #ifdef __ASSEMBLY__ 20 23 # define __IA64_UL(x) (x)
+3 -1
arch/ia64/include/asm/unistd.h
··· 310 310 #define __NR_inotify_init1 1318 311 311 #define __NR_preadv 1319 312 312 #define __NR_pwritev 1320 313 + #define __NR_rt_tgsigqueueinfo 1321 313 314 314 315 #ifdef __KERNEL__ 315 316 316 317 317 - #define NR_syscalls 297 /* length of syscall table */ 318 + #define NR_syscalls 298 /* length of syscall table */ 318 319 319 320 /* 320 321 * The following defines stop scripts/checksyscalls.sh from complaining about ··· 329 328 #define __IGNORE_utime /* utimes() */ 330 329 #define __IGNORE_getpgrp /* getpgid() */ 331 330 #define __IGNORE_vfork /* clone() */ 331 + #define __IGNORE_umount2 /* umount() */ 332 332 333 333 #define __ARCH_WANT_SYS_RT_SIGACTION 334 334 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+5 -5
arch/ia64/kernel/efi.c
··· 46 46 struct efi efi; 47 47 EXPORT_SYMBOL(efi); 48 48 static efi_runtime_services_t *runtime; 49 - static unsigned long mem_limit = ~0UL, max_addr = ~0UL, min_addr = 0UL; 49 + static u64 mem_limit = ~0UL, max_addr = ~0UL, min_addr = 0UL; 50 50 51 51 #define efi_call_virt(f, args...) (*(f))(args) 52 52 ··· 356 356 357 357 if (++pal_code_count > 1) { 358 358 printk(KERN_ERR "Too many EFI Pal Code memory ranges, " 359 - "dropped @ %lx\n", md->phys_addr); 359 + "dropped @ %llx\n", md->phys_addr); 360 360 continue; 361 361 } 362 362 /* ··· 490 490 } 491 491 } 492 492 if (min_addr != 0UL) 493 - printk(KERN_INFO "Ignoring memory below %luMB\n", 493 + printk(KERN_INFO "Ignoring memory below %lluMB\n", 494 494 min_addr >> 20); 495 495 if (max_addr != ~0UL) 496 - printk(KERN_INFO "Ignoring memory above %luMB\n", 496 + printk(KERN_INFO "Ignoring memory above %lluMB\n", 497 497 max_addr >> 20); 498 498 499 499 efi.systab = __va(ia64_boot_param->efi_systab); ··· 1066 1066 * parts exist, and are WB. 1067 1067 */ 1068 1068 unsigned long 1069 - efi_memmap_init(unsigned long *s, unsigned long *e) 1069 + efi_memmap_init(u64 *s, u64 *e) 1070 1070 { 1071 1071 struct kern_memdesc *k, *prev = NULL; 1072 1072 u64 contig_low=0, contig_high=0;
+1
arch/ia64/kernel/entry.S
··· 1805 1805 data8 sys_inotify_init1 1806 1806 data8 sys_preadv 1807 1807 data8 sys_pwritev // 1320 1808 + data8 sys_rt_tgsigqueueinfo 1808 1809 1809 1810 .org sys_call_table + 8*NR_syscalls // guard against failures to increase NR_syscalls 1810 1811 #endif /* __IA64_ASM_PARAVIRTUALIZED_NATIVE */
+5 -5
arch/ia64/kernel/iosapic.c
··· 451 451 static void 452 452 iosapic_ack_edge_irq (unsigned int irq) 453 453 { 454 - irq_desc_t *idesc = irq_desc + irq; 454 + struct irq_desc *idesc = irq_desc + irq; 455 455 456 456 irq_complete_move(irq); 457 457 move_native_irq(irq); ··· 600 600 register_intr (unsigned int gsi, int irq, unsigned char delivery, 601 601 unsigned long polarity, unsigned long trigger) 602 602 { 603 - irq_desc_t *idesc; 604 - struct hw_interrupt_type *irq_type; 603 + struct irq_desc *idesc; 604 + struct irq_chip *irq_type; 605 605 int index; 606 606 struct iosapic_rte_info *rte; 607 607 ··· 650 650 651 651 idesc = irq_desc + irq; 652 652 if (irq_type != NULL && idesc->chip != irq_type) { 653 - if (idesc->chip != &no_irq_type) 653 + if (idesc->chip != &no_irq_chip) 654 654 printk(KERN_WARNING 655 655 "%s: changing vector %d from %s to %s\n", 656 656 __func__, irq_to_vector(irq), ··· 828 828 { 829 829 unsigned long flags; 830 830 int irq, index; 831 - irq_desc_t *idesc; 831 + struct irq_desc *idesc; 832 832 u32 low32; 833 833 unsigned long trigger, polarity; 834 834 unsigned int dest;
+1 -1
arch/ia64/kernel/irq.c
··· 130 130 */ 131 131 static void migrate_irqs(void) 132 132 { 133 - irq_desc_t *desc; 133 + struct irq_desc *desc; 134 134 int irq, new_cpu; 135 135 136 136 for (irq=0; irq < NR_IRQS; irq++) {
+1 -1
arch/ia64/kernel/irq_ia64.c
··· 630 630 void 631 631 ia64_native_register_percpu_irq (ia64_vector vec, struct irqaction *action) 632 632 { 633 - irq_desc_t *desc; 633 + struct irq_desc *desc; 634 634 unsigned int irq; 635 635 636 636 irq = vec;
+1 -1
arch/ia64/kernel/irq_lsapic.c
··· 33 33 return 1; 34 34 } 35 35 36 - struct hw_interrupt_type irq_type_ia64_lsapic = { 36 + struct irq_chip irq_type_ia64_lsapic = { 37 37 .name = "LSAPIC", 38 38 .startup = lsapic_noop_startup, 39 39 .shutdown = lsapic_noop,
+10 -10
arch/ia64/kernel/mca.c
··· 850 850 851 851 852 852 static inline void 853 - copy_reg(const u64 *fr, u64 fnat, u64 *tr, u64 *tnat) 853 + copy_reg(const u64 *fr, u64 fnat, unsigned long *tr, unsigned long *tnat) 854 854 { 855 855 u64 fslot, tslot, nat; 856 856 *tr = *fr; ··· 914 914 struct switch_stack *old_sw; 915 915 unsigned size = sizeof(struct pt_regs) + 916 916 sizeof(struct switch_stack) + 16; 917 - u64 *old_bspstore, *old_bsp; 918 - u64 *new_bspstore, *new_bsp; 919 - u64 old_unat, old_rnat, new_rnat, nat; 917 + unsigned long *old_bspstore, *old_bsp; 918 + unsigned long *new_bspstore, *new_bsp; 919 + unsigned long old_unat, old_rnat, new_rnat, nat; 920 920 u64 slots, loadrs = regs->loadrs; 921 921 u64 r12 = ms->pmsa_gr[12-1], r13 = ms->pmsa_gr[13-1]; 922 922 u64 ar_bspstore = regs->ar_bspstore; ··· 968 968 * loadrs for the new stack and save it in the new pt_regs, where 969 969 * ia64_old_stack() can get it. 970 970 */ 971 - old_bspstore = (u64 *)ar_bspstore; 972 - old_bsp = (u64 *)ar_bsp; 971 + old_bspstore = (unsigned long *)ar_bspstore; 972 + old_bsp = (unsigned long *)ar_bsp; 973 973 slots = ia64_rse_num_regs(old_bspstore, old_bsp); 974 - new_bspstore = (u64 *)((u64)current + IA64_RBS_OFFSET); 974 + new_bspstore = (unsigned long *)((u64)current + IA64_RBS_OFFSET); 975 975 new_bsp = ia64_rse_skip_regs(new_bspstore, slots); 976 976 regs->loadrs = (new_bsp - new_bspstore) * 8 << 16; 977 977 ··· 1917 1917 ia64_fptr_t *init_hldlr_ptr_slave = (ia64_fptr_t *)ia64_os_init_dispatch_slave; 1918 1918 ia64_fptr_t *mca_hldlr_ptr = (ia64_fptr_t *)ia64_os_mca_dispatch; 1919 1919 int i; 1920 - s64 rc; 1920 + long rc; 1921 1921 struct ia64_sal_retval isrv; 1922 - u64 timeout = IA64_MCA_RENDEZ_TIMEOUT; /* platform specific */ 1922 + unsigned long timeout = IA64_MCA_RENDEZ_TIMEOUT; /* platform specific */ 1923 1923 static struct notifier_block default_init_monarch_nb = { 1924 1924 .notifier_call = default_monarch_init_process, 1925 1925 .priority = 0/* we need to notified last */ ··· 2092 2092 cpe_poll_timer.function = ia64_mca_cpe_poll; 2093 2093 2094 2094 { 2095 - irq_desc_t *desc; 2095 + struct irq_desc *desc; 2096 2096 unsigned int irq; 2097 2097 2098 2098 if (cpe_vector >= 0) {
+9 -5
arch/ia64/kernel/module.c
··· 171 171 return 0; 172 172 } 173 173 if (val + ((uint64_t) 1 << 59) >= (1UL << 60)) { 174 - printk(KERN_ERR "%s: value %ld out of IMM60 range\n", mod->name, (int64_t) val); 174 + printk(KERN_ERR "%s: value %ld out of IMM60 range\n", 175 + mod->name, (long) val); 175 176 return 0; 176 177 } 177 178 ia64_patch_imm60((u64) insn, val); ··· 183 182 apply_imm22 (struct module *mod, struct insn *insn, uint64_t val) 184 183 { 185 184 if (val + (1 << 21) >= (1 << 22)) { 186 - printk(KERN_ERR "%s: value %li out of IMM22 range\n", mod->name, (int64_t)val); 185 + printk(KERN_ERR "%s: value %li out of IMM22 range\n", 186 + mod->name, (long)val); 187 187 return 0; 188 188 } 189 189 ia64_patch((u64) insn, 0x01fffcfe000UL, ( ((val & 0x200000UL) << 15) /* bit 21 -> 36 */ ··· 198 196 apply_imm21b (struct module *mod, struct insn *insn, uint64_t val) 199 197 { 200 198 if (val + (1 << 20) >= (1 << 21)) { 201 - printk(KERN_ERR "%s: value %li out of IMM21b range\n", mod->name, (int64_t)val); 199 + printk(KERN_ERR "%s: value %li out of IMM21b range\n", 200 + mod->name, (long)val); 202 201 return 0; 203 202 } 204 203 ia64_patch((u64) insn, 0x11ffffe000UL, ( ((val & 0x100000UL) << 16) /* bit 20 -> 36 */ ··· 704 701 case RV_PCREL2: 705 702 if (r_type == R_IA64_PCREL21BI) { 706 703 if (!is_internal(mod, val)) { 707 - printk(KERN_ERR "%s: %s reloc against non-local symbol (%lx)\n", 708 - __func__, reloc_name[r_type], val); 704 + printk(KERN_ERR "%s: %s reloc against " 705 + "non-local symbol (%lx)\n", __func__, 706 + reloc_name[r_type], (unsigned long)val); 709 707 return -ENOEXEC; 710 708 } 711 709 format = RF_INSN21B;
+1 -1
arch/ia64/kernel/msi_ia64.c
··· 158 158 } 159 159 #endif /* CONFIG_SMP */ 160 160 161 - struct irq_chip dmar_msi_type = { 161 + static struct irq_chip dmar_msi_type = { 162 162 .name = "DMAR_MSI", 163 163 .unmask = dmar_msi_unmask, 164 164 .mask = dmar_msi_mask,
+34 -34
arch/ia64/kernel/palinfo.c
··· 218 218 cache_info(char *page) 219 219 { 220 220 char *p = page; 221 - u64 i, levels, unique_caches; 221 + unsigned long i, levels, unique_caches; 222 222 pal_cache_config_info_t cci; 223 223 int j, k; 224 - s64 status; 224 + long status; 225 225 226 226 if ((status = ia64_pal_cache_summary(&levels, &unique_caches)) != 0) { 227 227 printk(KERN_ERR "ia64_pal_cache_summary=%ld\n", status); ··· 303 303 ia64_ptce_info_t ptce; 304 304 const char *sep; 305 305 int i, j; 306 - s64 status; 306 + long status; 307 307 308 308 if ((status = ia64_pal_vm_summary(&vm_info_1, &vm_info_2)) !=0) { 309 309 printk(KERN_ERR "ia64_pal_vm_summary=%ld\n", status); ··· 431 431 char *p = page; 432 432 u64 reg_info[2]; 433 433 u64 info; 434 - u64 phys_stacked; 434 + unsigned long phys_stacked; 435 435 pal_hints_u_t hints; 436 - u64 iregs, dregs; 436 + unsigned long iregs, dregs; 437 437 char *info_type[]={ 438 438 "Implemented AR(s)", 439 439 "AR(s) with read side-effects", ··· 530 530 NULL, NULL, NULL, NULL, 531 531 }; 532 532 533 - static char * 534 - feature_set_info(char *page, u64 avail, u64 status, u64 control, u64 set) 533 + static char * feature_set_info(char *page, u64 avail, u64 status, u64 control, 534 + unsigned long set) 535 535 { 536 536 char *p = page; 537 537 char **vf, **v; ··· 714 714 { 715 715 char *p = page; 716 716 struct pal_freq_ratio proc, itc, bus; 717 - u64 base; 717 + unsigned long base; 718 718 719 719 if (ia64_pal_freq_base(&base) == -1) 720 720 p += sprintf(p, "Output clock : not implemented\n"); ··· 736 736 tr_info(char *page) 737 737 { 738 738 char *p = page; 739 - s64 status; 739 + long status; 740 740 pal_tr_valid_u_t tr_valid; 741 741 u64 tr_buffer[4]; 742 742 pal_vm_info_1_u_t vm_info_1; 743 743 pal_vm_info_2_u_t vm_info_2; 744 - u64 i, j; 745 - u64 max[3], pgm; 744 + unsigned long i, j; 745 + unsigned long max[3], pgm; 746 746 struct ifa_reg { 747 - u64 valid:1; 748 - u64 ig:11; 749 - u64 vpn:52; 747 + unsigned long valid:1; 748 + unsigned long ig:11; 749 + unsigned long vpn:52; 750 750 } *ifa_reg; 751 751 struct itir_reg { 752 - u64 rv1:2; 753 - u64 ps:6; 754 - u64 key:24; 755 - u64 rv2:32; 752 + unsigned long rv1:2; 753 + unsigned long ps:6; 754 + unsigned long key:24; 755 + unsigned long rv2:32; 756 756 } *itir_reg; 757 757 struct gr_reg { 758 - u64 p:1; 759 - u64 rv1:1; 760 - u64 ma:3; 761 - u64 a:1; 762 - u64 d:1; 763 - u64 pl:2; 764 - u64 ar:3; 765 - u64 ppn:38; 766 - u64 rv2:2; 767 - u64 ed:1; 768 - u64 ig:11; 758 + unsigned long p:1; 759 + unsigned long rv1:1; 760 + unsigned long ma:3; 761 + unsigned long a:1; 762 + unsigned long d:1; 763 + unsigned long pl:2; 764 + unsigned long ar:3; 765 + unsigned long ppn:38; 766 + unsigned long rv2:2; 767 + unsigned long ed:1; 768 + unsigned long ig:11; 769 769 } *gr_reg; 770 770 struct rid_reg { 771 - u64 ig1:1; 772 - u64 rv1:1; 773 - u64 ig2:6; 774 - u64 rid:24; 775 - u64 rv2:32; 771 + unsigned long ig1:1; 772 + unsigned long rv1:1; 773 + unsigned long ig2:6; 774 + unsigned long rid:24; 775 + unsigned long rv2:32; 776 776 } *rid_reg; 777 777 778 778 if ((status = ia64_pal_vm_summary(&vm_info_1, &vm_info_2)) !=0) {
+2
arch/ia64/kernel/paravirt_patchlist.c
··· 19 19 */ 20 20 21 21 #include <linux/bug.h> 22 + #include <linux/init.h> 23 + #include <linux/kernel.h> 22 24 #include <asm/paravirt.h> 23 25 24 26 #define DECLARE(name) \
+1 -1
arch/ia64/kernel/pci-dma.c
··· 91 91 type. Normally this doesn't make any difference, but gives 92 92 more gentle handling of IOMMU overflow. */ 93 93 if (iommu_sac_force && (mask >= DMA_BIT_MASK(40))) { 94 - dev_info(dev, "Force SAC with mask %lx\n", mask); 94 + dev_info(dev, "Force SAC with mask %llx\n", mask); 95 95 return 0; 96 96 } 97 97
+3 -3
arch/ia64/kernel/perfmon.c
··· 312 312 unsigned long th_pmcs[PFM_NUM_PMC_REGS]; /* PMC thread save state */ 313 313 unsigned long th_pmds[PFM_NUM_PMD_REGS]; /* PMD thread save state */ 314 314 315 - u64 ctx_saved_psr_up; /* only contains psr.up value */ 315 + unsigned long ctx_saved_psr_up; /* only contains psr.up value */ 316 316 317 317 unsigned long ctx_last_activation; /* context last activation number for last_cpu */ 318 318 unsigned int ctx_last_cpu; /* CPU id of current or last CPU used (SMP only) */ ··· 5213 5213 * main overflow processing routine. 5214 5214 * it can be called from the interrupt path or explicitly during the context switch code 5215 5215 */ 5216 - static void 5217 - pfm_overflow_handler(struct task_struct *task, pfm_context_t *ctx, u64 pmc0, struct pt_regs *regs) 5216 + static void pfm_overflow_handler(struct task_struct *task, pfm_context_t *ctx, 5217 + unsigned long pmc0, struct pt_regs *regs) 5218 5218 { 5219 5219 pfm_ovfl_arg_t *ovfl_arg; 5220 5220 unsigned long mask;
+16 -16
arch/ia64/kernel/setup.c
··· 151 151 * This routine does not assume the incoming segments are sorted. 152 152 */ 153 153 int __init 154 - filter_rsvd_memory (unsigned long start, unsigned long end, void *arg) 154 + filter_rsvd_memory (u64 start, u64 end, void *arg) 155 155 { 156 - unsigned long range_start, range_end, prev_start; 156 + u64 range_start, range_end, prev_start; 157 157 void (*func)(unsigned long, unsigned long, int); 158 158 int i; 159 159 ··· 191 191 * are not filtered out. 192 192 */ 193 193 int __init 194 - filter_memory(unsigned long start, unsigned long end, void *arg) 194 + filter_memory(u64 start, u64 end, void *arg) 195 195 { 196 196 void (*func)(unsigned long, unsigned long, int); 197 197 ··· 397 397 initrd_start = (unsigned long)__va(ia64_boot_param->initrd_start); 398 398 initrd_end = initrd_start+ia64_boot_param->initrd_size; 399 399 400 - printk(KERN_INFO "Initial ramdisk at: 0x%lx (%lu bytes)\n", 400 + printk(KERN_INFO "Initial ramdisk at: 0x%lx (%llu bytes)\n", 401 401 initrd_start, ia64_boot_param->initrd_size); 402 402 } 403 403 #endif ··· 505 505 } 506 506 early_param("elfcorehdr", parse_elfcorehdr); 507 507 508 - int __init reserve_elfcorehdr(unsigned long *start, unsigned long *end) 508 + int __init reserve_elfcorehdr(u64 *start, u64 *end) 509 509 { 510 - unsigned long length; 510 + u64 length; 511 511 512 512 /* We get the address using the kernel command line, 513 513 * but the size is extracted from the EFI tables. ··· 588 588 ia64_patch_rse((u64) __start___rse_patchlist, (u64) __end___rse_patchlist); 589 589 #else 590 590 { 591 - u64 num_phys_stacked; 591 + unsigned long num_phys_stacked; 592 592 593 593 if (ia64_pal_rse_info(&num_phys_stacked, 0) == 0 && num_phys_stacked > 96) 594 594 ia64_patch_rse((u64) __start___rse_patchlist, (u64) __end___rse_patchlist); ··· 872 872 get_cache_info(void) 873 873 { 874 874 unsigned long line_size, max = 1; 875 - u64 l, levels, unique_caches; 876 - pal_cache_config_info_t cci; 877 - s64 status; 875 + unsigned long l, levels, unique_caches; 876 + pal_cache_config_info_t cci; 877 + long status; 878 878 879 879 status = ia64_pal_cache_summary(&levels, &unique_caches); 880 880 if (status != 0) { ··· 892 892 /* cache_type (data_or_unified)=2 */ 893 893 status = ia64_pal_cache_config_info(l, 2, &cci); 894 894 if (status != 0) { 895 - printk(KERN_ERR 896 - "%s: ia64_pal_cache_config_info(l=%lu, 2) failed (status=%ld)\n", 897 - __func__, l, status); 895 + printk(KERN_ERR "%s: ia64_pal_cache_config_info" 896 + "(l=%lu, 2) failed (status=%ld)\n", 897 + __func__, l, status); 898 898 max = SMP_CACHE_BYTES; 899 899 /* The safest setup for "flush_icache_range()" */ 900 900 cci.pcci_stride = I_CACHE_STRIDE_SHIFT; ··· 914 914 /* cache_type (instruction)=1*/ 915 915 status = ia64_pal_cache_config_info(l, 1, &cci); 916 916 if (status != 0) { 917 - printk(KERN_ERR 918 - "%s: ia64_pal_cache_config_info(l=%lu, 1) failed (status=%ld)\n", 917 + printk(KERN_ERR "%s: ia64_pal_cache_config_info" 918 + "(l=%lu, 1) failed (status=%ld)\n", 919 919 __func__, l, status); 920 - /* The safest setup for "flush_icache_range()" */ 920 + /* The safest setup for flush_icache_range() */ 921 921 cci.pcci_stride = I_CACHE_STRIDE_SHIFT; 922 922 } 923 923 }
+1 -1
arch/ia64/kernel/smp.c
··· 66 66 #define IPI_KDUMP_CPU_STOP 3 67 67 68 68 /* This needs to be cacheline aligned because it is written to by *other* CPUs. */ 69 - static DEFINE_PER_CPU_SHARED_ALIGNED(u64, ipi_operation); 69 + static DEFINE_PER_CPU_SHARED_ALIGNED(unsigned long, ipi_operation); 70 70 71 71 extern void cpu_halt (void); 72 72
+2 -2
arch/ia64/kernel/smpboot.c
··· 678 678 int migrate_platform_irqs(unsigned int cpu) 679 679 { 680 680 int new_cpei_cpu; 681 - irq_desc_t *desc = NULL; 681 + struct irq_desc *desc = NULL; 682 682 const struct cpumask *mask; 683 683 int retval = 0; 684 684 ··· 865 865 void __devinit 866 866 identify_siblings(struct cpuinfo_ia64 *c) 867 867 { 868 - s64 status; 868 + long status; 869 869 u16 pltid; 870 870 pal_logical_to_physical_t info; 871 871
+1 -1
arch/ia64/kernel/time.c
··· 385 385 386 386 static cycle_t itc_get_cycles(struct clocksource *cs) 387 387 { 388 - u64 lcycle, now, ret; 388 + unsigned long lcycle, now, ret; 389 389 390 390 if (!itc_jitter_data.itc_jitter) 391 391 return get_cycles();
+2 -2
arch/ia64/kernel/topology.c
··· 306 306 307 307 static int __cpuinit cpu_cache_sysfs_init(unsigned int cpu) 308 308 { 309 - u64 i, levels, unique_caches; 309 + unsigned long i, levels, unique_caches; 310 310 pal_cache_config_info_t cci; 311 311 int j; 312 - s64 status; 312 + long status; 313 313 struct cache_info *this_cache; 314 314 int num_cache_leaves = 0; 315 315
+1 -2
arch/ia64/kernel/uncached.c
··· 250 250 * Called at boot time to build a map of pages that can be used for 251 251 * memory special operations. 252 252 */ 253 - static int __init uncached_build_memmap(unsigned long uc_start, 254 - unsigned long uc_end, void *arg) 253 + static int __init uncached_build_memmap(u64 uc_start, u64 uc_end, void *arg) 255 254 { 256 255 int nid = paddr_to_nid(uc_start - __IA64_UNCACHED_OFFSET); 257 256 struct gen_pool *pool = uncached_pools[nid].pool;
+4 -5
arch/ia64/mm/contig.c
··· 107 107 * bootmap_start. This address must be page-aligned. 108 108 */ 109 109 static int __init 110 - find_bootmap_location (unsigned long start, unsigned long end, void *arg) 110 + find_bootmap_location (u64 start, u64 end, void *arg) 111 111 { 112 - unsigned long needed = *(unsigned long *)arg; 113 - unsigned long range_start, range_end, free_start; 112 + u64 needed = *(unsigned long *)arg; 113 + u64 range_start, range_end, free_start; 114 114 int i; 115 115 116 116 #if IGNORE_PFN0 ··· 229 229 alloc_per_cpu_data(); 230 230 } 231 231 232 - static int 233 - count_pages (u64 start, u64 end, void *arg) 232 + static int count_pages(u64 start, u64 end, void *arg) 234 233 { 235 234 unsigned long *count = arg; 236 235
+6 -9
arch/ia64/mm/init.c
··· 422 422 return hole_next_pfn - pgdat->node_start_pfn; 423 423 } 424 424 425 - int __init 426 - create_mem_map_page_table (u64 start, u64 end, void *arg) 425 + int __init create_mem_map_page_table(u64 start, u64 end, void *arg) 427 426 { 428 427 unsigned long address, start_page, end_page; 429 428 struct page *map_start, *map_end; ··· 468 469 }; 469 470 470 471 static int __meminit 471 - virtual_memmap_init (u64 start, u64 end, void *arg) 472 + virtual_memmap_init(u64 start, u64 end, void *arg) 472 473 { 473 474 struct memmap_init_callback_data *args; 474 475 struct page *map_start, *map_end; ··· 530 531 } 531 532 EXPORT_SYMBOL(ia64_pfn_valid); 532 533 533 - int __init 534 - find_largest_hole (u64 start, u64 end, void *arg) 534 + int __init find_largest_hole(u64 start, u64 end, void *arg) 535 535 { 536 536 u64 *max_gap = arg; 537 537 ··· 546 548 547 549 #endif /* CONFIG_VIRTUAL_MEM_MAP */ 548 550 549 - int __init 550 - register_active_ranges(u64 start, u64 len, int nid) 551 + int __init register_active_ranges(u64 start, u64 len, int nid) 551 552 { 552 553 u64 end = start + len; 553 554 ··· 564 567 } 565 568 566 569 static int __init 567 - count_reserved_pages (u64 start, u64 end, void *arg) 570 + count_reserved_pages(u64 start, u64 end, void *arg) 568 571 { 569 572 unsigned long num_reserved = 0; 570 573 unsigned long *count = arg; ··· 577 580 } 578 581 579 582 int 580 - find_max_min_low_pfn (unsigned long start, unsigned long end, void *arg) 583 + find_max_min_low_pfn (u64 start, u64 end, void *arg) 581 584 { 582 585 unsigned long pfn_start, pfn_end; 583 586 #ifdef CONFIG_FLATMEM
+2 -2
arch/ia64/mm/tlb.c
··· 34 34 #include <asm/tlb.h> 35 35 36 36 static struct { 37 - unsigned long mask; /* mask of supported purge page-sizes */ 37 + u64 mask; /* mask of supported purge page-sizes */ 38 38 unsigned long max_bits; /* log2 of largest supported purge page-size */ 39 39 } purge; 40 40 ··· 328 328 ia64_tlb_init (void) 329 329 { 330 330 ia64_ptce_info_t uninitialized_var(ptce_info); /* GCC be quiet */ 331 - unsigned long tr_pgbits; 331 + u64 tr_pgbits; 332 332 long status; 333 333 pal_vm_info_1_u_t vm_info_1; 334 334 pal_vm_info_2_u_t vm_info_2;
+6 -6
arch/ia64/pci/pci.c
··· 163 163 { 164 164 struct resource *resource; 165 165 char *name; 166 - u64 base, min, max, base_port; 166 + unsigned long base, min, max, base_port; 167 167 unsigned int sparse = 0, space_nr, len; 168 168 169 169 resource = kzalloc(sizeof(*resource), GFP_KERNEL); ··· 292 292 window->offset = offset; 293 293 294 294 if (insert_resource(root, &window->resource)) { 295 - printk(KERN_ERR "alloc 0x%lx-0x%lx from %s for %s failed\n", 295 + printk(KERN_ERR "alloc 0x%llx-0x%llx from %s for %s failed\n", 296 296 window->resource.start, window->resource.end, 297 297 root->name, info->name); 298 298 } ··· 314 314 (res->end - res->start < 16)) 315 315 continue; 316 316 if (j >= PCI_BUS_NUM_RESOURCES) { 317 - printk("Ignoring range [%lx-%lx] (%lx)\n", res->start, 318 - res->end, res->flags); 317 + printk("Ignoring range [%#llx-%#llx] (%lx)\n", 318 + res->start, res->end, res->flags); 319 319 continue; 320 320 } 321 321 bus->resource[j++] = res; ··· 728 728 */ 729 729 static void __init set_pci_cacheline_size(void) 730 730 { 731 - u64 levels, unique_caches; 732 - s64 status; 731 + unsigned long levels, unique_caches; 732 + long status; 733 733 pal_cache_config_info_t cci; 734 734 735 735 status = ia64_pal_cache_summary(&levels, &unique_caches);
+2 -2
arch/ia64/sn/kernel/io_acpi_init.c
··· 40 40 /* 41 41 * Perform the early IO init in PROM. 42 42 */ 43 - static s64 43 + static long 44 44 sal_ioif_init(u64 *result) 45 45 { 46 46 struct ia64_sal_retval isrv = {0,0,0,0}; ··· 492 492 sn_io_acpi_init(void) 493 493 { 494 494 u64 result; 495 - s64 status; 495 + long status; 496 496 497 497 /* SN Altix does not follow the IOSAPIC IRQ routing model */ 498 498 acpi_irq_model = ACPI_IRQ_MODEL_PLATFORM;
+1 -1
arch/ia64/sn/kernel/io_common.c
··· 342 342 struct pcibus_bussoft *b = SN_PCIBUS_BUSSOFT(bus); 343 343 344 344 printk(KERN_WARNING "Device ASIC=%u XID=%u PBUSNUM=%u " 345 - "L_IO=%lx L_MEM=%lx BASE=%lx\n", 345 + "L_IO=%llx L_MEM=%llx BASE=%llx\n", 346 346 b->bs_asic_type, b->bs_xid, b->bs_persist_busnum, 347 347 b->bs_legacy_io, b->bs_legacy_mem, b->bs_base); 348 348 printk(KERN_WARNING "on node %d but only %d nodes online."
+3 -3
arch/ia64/sn/kernel/irq.c
··· 295 295 void sn_irq_init(void) 296 296 { 297 297 int i; 298 - irq_desc_t *base_desc = irq_desc; 298 + struct irq_desc *base_desc = irq_desc; 299 299 300 300 ia64_first_device_vector = IA64_SN2_FIRST_DEVICE_VECTOR; 301 301 ia64_last_device_vector = IA64_SN2_LAST_DEVICE_VECTOR; 302 302 303 303 for (i = 0; i < NR_IRQS; i++) { 304 - if (base_desc[i].chip == &no_irq_type) { 304 + if (base_desc[i].chip == &no_irq_chip) { 305 305 base_desc[i].chip = &irq_type_sn; 306 306 } 307 307 } ··· 377 377 int cpu = nasid_slice_to_cpuid(nasid, slice); 378 378 #ifdef CONFIG_SMP 379 379 int cpuphys; 380 - irq_desc_t *desc; 380 + struct irq_desc *desc; 381 381 #endif 382 382 383 383 pci_dev_get(pci_dev);
+2 -2
arch/ia64/sn/kernel/sn2/sn_hwperf.c
··· 414 414 } 415 415 seq_printf(s, "partition %u %s local " 416 416 "shubtype %s, " 417 - "nasid_mask 0x%016lx, " 417 + "nasid_mask 0x%016llx, " 418 418 "nasid_bits %d:%d, " 419 419 "system_size %d, " 420 420 "sharing_size %d, " ··· 683 683 * ioctl for "sn_hwperf" misc device 684 684 */ 685 685 static int 686 - sn_hwperf_ioctl(struct inode *in, struct file *fp, u32 op, u64 arg) 686 + sn_hwperf_ioctl(struct inode *in, struct file *fp, u32 op, unsigned long arg) 687 687 { 688 688 struct sn_hwperf_ioctl_args a; 689 689 struct cpuinfo_ia64 *cdata;
+1 -1
arch/ia64/sn/kernel/sn2/sn_proc_fs.c
··· 36 36 37 37 static int licenseID_show(struct seq_file *s, void *p) 38 38 { 39 - seq_printf(s, "0x%lx\n", sn_partition_serial_number_val()); 39 + seq_printf(s, "0x%llx\n", sn_partition_serial_number_val()); 40 40 return 0; 41 41 } 42 42
+1 -1
arch/ia64/sn/kernel/tiocx.c
··· 368 368 static int is_fpga_tio(int nasid, int *bt) 369 369 { 370 370 u16 uninitialized_var(ioboard_type); /* GCC be quiet */ 371 - s64 rc; 371 + long rc; 372 372 373 373 rc = ia64_sn_sysctl_ioboard_get(nasid, &ioboard_type); 374 374 if (rc) {
+1 -1
arch/ia64/sn/pci/pcibr/pcibr_provider.c
··· 79 79 80 80 u16 sn_ioboard_to_pci_bus(struct pci_bus *pci_bus) 81 81 { 82 - s64 rc; 82 + long rc; 83 83 u16 uninitialized_var(ioboard); /* GCC be quiet */ 84 84 nasid_t nasid = NASID_GET(SN_PCIBUS_BUSSOFT(pci_bus)->bs_base); 85 85
+3 -3
arch/ia64/sn/pci/tioca_provider.c
··· 123 123 124 124 if (!tmp) { 125 125 printk(KERN_ERR "%s: Could not allocate " 126 - "%lu bytes (order %d) for GART\n", 126 + "%llu bytes (order %d) for GART\n", 127 127 __func__, 128 128 tioca_kern->ca_gart_size, 129 129 get_order(tioca_kern->ca_gart_size)); ··· 348 348 agp_dma_extn = __sn_readq_relaxed(&ca_base->ca_agp_dma_addr_extn); 349 349 if (node_upper != (agp_dma_extn >> CA_AGP_DMA_NODE_ID_SHFT)) { 350 350 printk(KERN_ERR "%s: coretalk upper node (%u) " 351 - "mismatch with ca_agp_dma_addr_extn (%lu)\n", 351 + "mismatch with ca_agp_dma_addr_extn (%llu)\n", 352 352 __func__, 353 353 node_upper, (agp_dma_extn >> CA_AGP_DMA_NODE_ID_SHFT)); 354 354 return 0; ··· 367 367 * dma_addr_t is guaranteed to be contiguous in CA bus space. 368 368 */ 369 369 static dma_addr_t 370 - tioca_dma_mapped(struct pci_dev *pdev, u64 paddr, size_t req_size) 370 + tioca_dma_mapped(struct pci_dev *pdev, unsigned long paddr, size_t req_size) 371 371 { 372 372 int i, ps, ps_shift, entry, entries, mapsize, last_entry; 373 373 u64 xio_addr, end_xio_addr;
+3 -3
arch/ia64/sn/pci/tioce_provider.c
··· 493 493 494 494 if (&map->ce_dmamap_list == &ce_kern->ce_dmamap_list) { 495 495 printk(KERN_WARNING 496 - "%s: %s - no map found for bus_addr 0x%lx\n", 496 + "%s: %s - no map found for bus_addr 0x%llx\n", 497 497 __func__, pci_name(pdev), bus_addr); 498 498 } else if (--map->refcnt == 0) { 499 499 for (i = 0; i < map->ate_count; i++) { ··· 642 642 * in the address. 643 643 */ 644 644 static u64 645 - tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags) 645 + tioce_dma(struct pci_dev *pdev, unsigned long paddr, size_t byte_count, int dma_flags) 646 646 { 647 647 return tioce_do_dma_map(pdev, paddr, byte_count, 0, dma_flags); 648 648 } ··· 657 657 * in the address. 658 658 */ 659 659 static u64 660 - tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags) 660 + tioce_dma_consistent(struct pci_dev *pdev, unsigned long paddr, size_t byte_count, int dma_flags) 661 661 { 662 662 return tioce_do_dma_map(pdev, paddr, byte_count, 1, dma_flags); 663 663 }
+1 -1
arch/ia64/xen/irq_xen.c
··· 138 138 __xen_register_percpu_irq(unsigned int cpu, unsigned int vec, 139 139 struct irqaction *action, int save) 140 140 { 141 - irq_desc_t *desc; 141 + struct irq_desc *desc; 142 142 int irq = 0; 143 143 144 144 if (xen_slab_ready) {
+3 -2
drivers/char/agp/hp-agp.c
··· 518 518 if (hp_zx1_setup(sba_hpa + HP_ZX1_IOC_OFFSET, lba_hpa)) 519 519 return AE_OK; 520 520 521 - printk(KERN_INFO PFX "Detected HP ZX1 %s AGP chipset (ioc=%lx, lba=%lx)\n", 522 - (char *) context, sba_hpa + HP_ZX1_IOC_OFFSET, lba_hpa); 521 + printk(KERN_INFO PFX "Detected HP ZX1 %s AGP chipset " 522 + "(ioc=%llx, lba=%llx)\n", (char *)context, 523 + sba_hpa + HP_ZX1_IOC_OFFSET, lba_hpa); 523 524 524 525 hp_zx1_gart_found = 1; 525 526 return AE_CTRL_TERMINATE; /* we only support one bridge; quit looking */
+2 -2
drivers/firmware/pcdp.c
··· 28 28 char parity; 29 29 30 30 mmio = (uart->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY); 31 - p += sprintf(p, "uart8250,%s,0x%lx", 31 + p += sprintf(p, "uart8250,%s,0x%llx", 32 32 mmio ? "mmio" : "io", uart->addr.address); 33 33 if (uart->baud) { 34 - p += sprintf(p, ",%lu", uart->baud); 34 + p += sprintf(p, ",%llu", uart->baud); 35 35 if (uart->bits) { 36 36 switch (uart->parity) { 37 37 case 0x2: parity = 'e'; break;
+1 -1
include/linux/efi.h
··· 101 101 u64 attribute; 102 102 } efi_memory_desc_t; 103 103 104 - typedef int (*efi_freemem_callback_t) (unsigned long start, unsigned long end, void *arg); 104 + typedef int (*efi_freemem_callback_t) (u64 start, u64 end, void *arg); 105 105 106 106 /* 107 107 * Types and defines for Time Services