Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cff52daf authored by Al Viro's avatar Al Viro Committed by Linus Torvalds
Browse files

[PATCH] alpha_ksyms.c cleanup 



taken exports to actual definitions of symbols being exported.

Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 9ab6a453

arch/alpha/kernel/alpha_ksyms.c

+1 −92
Original line number Diff line number Diff line
@@ -6,41 +6,14 @@ 
 */



#include <linux/module.h>

#include <linux/string.h>

#include <linux/user.h>

#include <linux/elfcore.h>

#include <linux/socket.h>

#include <linux/syscalls.h>

#include <linux/in.h>

#include <linux/in6.h>

#include <linux/pci.h>

#include <linux/screen_info.h>

#include <linux/tty.h>

#include <linux/mm.h>

#include <linux/delay.h>

#include <linux/dma-mapping.h>



#include <asm/io.h>

#include <asm/console.h>

#include <asm/hwrpb.h>

#include <asm/uaccess.h>

#include <asm/processor.h>

#include <asm/checksum.h>

#include <linux/interrupt.h>

#include <asm/fpu.h>

#include <asm/irq.h>

#include <asm/machvec.h>

#include <asm/pgalloc.h>

#include <asm/semaphore.h>

#include <asm/tlbflush.h>

#include <asm/cacheflush.h>

#include <asm/vga.h>



#include <asm/unistd.h>



extern struct hwrpb_struct *hwrpb;

extern spinlock_t rtc_lock;



/* these are C runtime functions with special calling conventions: */

extern void __divl (void);

extern void __reml (void);
@@ -52,14 +25,9 @@ extern void __divqu (void); 
extern void __remqu (void);



EXPORT_SYMBOL(alpha_mv);

EXPORT_SYMBOL(screen_info);

EXPORT_SYMBOL(perf_irq);

EXPORT_SYMBOL(callback_getenv);

EXPORT_SYMBOL(callback_setenv);

EXPORT_SYMBOL(callback_save_env);

#ifdef CONFIG_ALPHA_GENERIC

EXPORT_SYMBOL(alpha_using_srm);

#endif /* CONFIG_ALPHA_GENERIC */



/* platform dependent support */

EXPORT_SYMBOL(strcat);
@@ -77,47 +45,14 @@ EXPORT_SYMBOL(__constant_c_memset); 
EXPORT_SYMBOL(copy_page);

EXPORT_SYMBOL(clear_page);



EXPORT_SYMBOL(__direct_map_base);

EXPORT_SYMBOL(__direct_map_size);



#ifdef CONFIG_PCI

EXPORT_SYMBOL(pci_alloc_consistent);

EXPORT_SYMBOL(pci_free_consistent);

EXPORT_SYMBOL(pci_map_single);

EXPORT_SYMBOL(pci_map_page);

EXPORT_SYMBOL(pci_unmap_single);

EXPORT_SYMBOL(pci_unmap_page);

EXPORT_SYMBOL(pci_map_sg);

EXPORT_SYMBOL(pci_unmap_sg);

EXPORT_SYMBOL(pci_dma_supported);

EXPORT_SYMBOL(pci_dac_dma_supported);

EXPORT_SYMBOL(pci_dac_page_to_dma);

EXPORT_SYMBOL(pci_dac_dma_to_page);

EXPORT_SYMBOL(pci_dac_dma_to_offset);

EXPORT_SYMBOL(alpha_gendev_to_pci);

#endif

EXPORT_SYMBOL(dma_set_mask);



EXPORT_SYMBOL(dump_thread);

EXPORT_SYMBOL(dump_elf_thread);

EXPORT_SYMBOL(dump_elf_task);

EXPORT_SYMBOL(dump_elf_task_fp);

EXPORT_SYMBOL(hwrpb);

EXPORT_SYMBOL(start_thread);

EXPORT_SYMBOL(alpha_read_fp_reg);

EXPORT_SYMBOL(alpha_read_fp_reg_s);

EXPORT_SYMBOL(alpha_write_fp_reg);

EXPORT_SYMBOL(alpha_write_fp_reg_s);



/* In-kernel system calls.  */

/* entry.S */

EXPORT_SYMBOL(kernel_thread);

EXPORT_SYMBOL(sys_dup);

EXPORT_SYMBOL(sys_exit);

EXPORT_SYMBOL(sys_write);

EXPORT_SYMBOL(sys_lseek);

EXPORT_SYMBOL(kernel_execve);

EXPORT_SYMBOL(sys_setsid);

EXPORT_SYMBOL(sys_wait4);



/* Networking helper routines. */

EXPORT_SYMBOL(csum_tcpudp_magic);
@@ -134,10 +69,6 @@ EXPORT_SYMBOL(alpha_fp_emul_imprecise); 
EXPORT_SYMBOL(alpha_fp_emul);

#endif



#ifdef CONFIG_ALPHA_BROKEN_IRQ_MASK

EXPORT_SYMBOL(__min_ipl);

#endif



/*

 * The following are specially called from the uaccess assembly stubs.

 */
@@ -160,26 +91,9 @@ EXPORT_SYMBOL(up); 
 */



#ifdef CONFIG_SMP

EXPORT_SYMBOL(flush_tlb_mm);

EXPORT_SYMBOL(flush_tlb_range);

EXPORT_SYMBOL(flush_tlb_page);

EXPORT_SYMBOL(smp_imb);

EXPORT_SYMBOL(cpu_data);

EXPORT_SYMBOL(smp_num_cpus);

EXPORT_SYMBOL(smp_call_function);

EXPORT_SYMBOL(smp_call_function_on_cpu);

EXPORT_SYMBOL(_atomic_dec_and_lock);

#endif /* CONFIG_SMP */



/*

 * NUMA specific symbols

 */

#ifdef CONFIG_DISCONTIGMEM

EXPORT_SYMBOL(node_data);

#endif /* CONFIG_DISCONTIGMEM */



EXPORT_SYMBOL(rtc_lock);



/*

 * The following are special because they're not called

 * explicitly (the C compiler or assembler generates them in
@@ -200,8 +114,3 @@ EXPORT_SYMBOL(__remqu); 
EXPORT_SYMBOL(memcpy);

EXPORT_SYMBOL(memset);

EXPORT_SYMBOL(memchr);
 


#ifdef CONFIG_ALPHA_IRONGATE

EXPORT_SYMBOL(irongate_ioremap);

EXPORT_SYMBOL(irongate_iounmap);

#endif

arch/alpha/kernel/core_irongate.c

+2 −0
Original line number Diff line number Diff line
@@ -404,6 +404,7 @@ irongate_ioremap(unsigned long addr, unsigned long size) 
#endif

	return (void __iomem *)vaddr;

}

EXPORT_SYMBOL(irongate_ioremap);



void

irongate_iounmap(volatile void __iomem *xaddr)
@@ -414,3 +415,4 @@ irongate_iounmap(volatile void __iomem *xaddr) 
	if (addr)

		return vfree((void *)(PAGE_MASK & addr)); 

}

EXPORT_SYMBOL(irongate_iounmap);

arch/alpha/kernel/irq_alpha.c

+3 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
#include <linux/sched.h>

#include <linux/irq.h>

#include <linux/kernel_stat.h>

#include <linux/module.h>



#include <asm/machvec.h>

#include <asm/dma.h>
@@ -16,6 +17,7 @@ 
/* Hack minimum IPL during interrupt processing for broken hardware.  */

#ifdef CONFIG_ALPHA_BROKEN_IRQ_MASK

int __min_ipl;

EXPORT_SYMBOL(__min_ipl);

#endif



/*
@@ -30,6 +32,7 @@ dummy_perf(unsigned long vector, struct pt_regs *regs) 
}



void (*perf_irq)(unsigned long, struct pt_regs *) = dummy_perf;

EXPORT_SYMBOL(perf_irq);



/*

 * The main interrupt entry point.

arch/alpha/kernel/pci-noop.c

+1 −0
Original line number Diff line number Diff line
@@ -201,6 +201,7 @@ dma_set_mask(struct device *dev, u64 mask) 


	return 0;

}

EXPORT_SYMBOL(dma_set_mask);



void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)

{

arch/alpha/kernel/pci_iommu.c

+15 −2
Original line number Diff line number Diff line
@@ -300,6 +300,7 @@ pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size, int dir) 
	dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; 

	return pci_map_single_1(pdev, cpu_addr, size, dac_allowed);

}

EXPORT_SYMBOL(pci_map_single);



dma_addr_t

pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset,
@@ -314,6 +315,7 @@ pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset, 
	return pci_map_single_1(pdev, (char *)page_address(page) + offset, 

				size, dac_allowed);

}

EXPORT_SYMBOL(pci_map_page);



/* Unmap a single streaming mode DMA translation.  The DMA_ADDR and

   SIZE must match what was provided for in a previous pci_map_single
@@ -379,6 +381,7 @@ pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size, 
	DBGA2("pci_unmap_single: sg [%lx,%lx] np %ld from %p\n",

	      dma_addr, size, npages, __builtin_return_address(0));

}

EXPORT_SYMBOL(pci_unmap_single);



void

pci_unmap_page(struct pci_dev *pdev, dma_addr_t dma_addr,
@@ -386,6 +389,7 @@ pci_unmap_page(struct pci_dev *pdev, dma_addr_t dma_addr, 
{

	pci_unmap_single(pdev, dma_addr, size, direction);

}

EXPORT_SYMBOL(pci_unmap_page);



/* Allocate and map kernel buffer using consistent mode DMA for PCI

   device.  Returns non-NULL cpu-view pointer to the buffer if
@@ -427,6 +431,7 @@ try_again: 


	return cpu_addr;

}

EXPORT_SYMBOL(pci_alloc_consistent);



/* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must

   be values that were returned from pci_alloc_consistent.  SIZE must
@@ -444,7 +449,7 @@ pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr, 
	DBGA2("pci_free_consistent: [%x,%lx] from %p\n",

	      dma_addr, size, __builtin_return_address(0));

}



EXPORT_SYMBOL(pci_free_consistent);



/* Classify the elements of the scatterlist.  Write dma_address

   of each element with:
@@ -672,6 +677,7 @@ pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, 
		pci_unmap_sg(pdev, start, out - start, direction);

	return 0;

}

EXPORT_SYMBOL(pci_map_sg);



/* Unmap a set of streaming mode DMA translations.  Again, cpu read

   rules concerning calls here are the same as for pci_unmap_single()
@@ -752,6 +758,7 @@ pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, 


	DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg));

}

EXPORT_SYMBOL(pci_unmap_sg);





/* Return whether the given PCI device DMA address mask can be
@@ -786,6 +793,7 @@ pci_dma_supported(struct pci_dev *pdev, u64 mask) 


	return 0;

}

EXPORT_SYMBOL(pci_dma_supported);





/*
@@ -908,6 +916,7 @@ pci_dac_dma_supported(struct pci_dev *dev, u64 mask) 


	return ok;

}

EXPORT_SYMBOL(pci_dac_dma_supported);



dma64_addr_t

pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page,
@@ -917,6 +926,7 @@ pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, 
		+ __pa(page_address(page)) 

		+ (dma64_addr_t) offset);

}

EXPORT_SYMBOL(pci_dac_page_to_dma);



struct page *

pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
@@ -924,13 +934,14 @@ pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr) 
	unsigned long paddr = (dma_addr & PAGE_MASK) - alpha_mv.pci_dac_offset;

	return virt_to_page(__va(paddr));

}

EXPORT_SYMBOL(pci_dac_dma_to_page);



unsigned long

pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)

{

	return (dma_addr & ~PAGE_MASK);

}



EXPORT_SYMBOL(pci_dac_dma_to_offset);



/* Helper for generic DMA-mapping functions. */
@@ -957,6 +968,7 @@ alpha_gendev_to_pci(struct device *dev) 
	/* This assumes ISA bus master with dma_mask 0xffffff. */

	return NULL;

}

EXPORT_SYMBOL(alpha_gendev_to_pci);



int

dma_set_mask(struct device *dev, u64 mask)
@@ -969,3 +981,4 @@ dma_set_mask(struct device *dev, u64 mask) 


	return 0;

}

EXPORT_SYMBOL(dma_set_mask);