tree 2871af7b098f51c5c64b8bfb96710db0e00468e8
parent 2551a13e61d3c3df6c2da6de5a3ece78e6d67111
author Randy Dunlap <randy.dunlap@oracle.com> 1193682035 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1200097684 -0600

[SCSI] aic94xx: fix section mismatches

Fix section mismatch warning:

WARNING: vmlinux.o(.init.text+0x23be6): Section mismatch: reference to .exit.text:asd_unmap_ha (between 'asd_pci_probe' and 'qla4xxx_module_init')
+
WARNING: vmlinux.o(.text+0x1ec8a8): Section mismatch: reference to .exit.text:as
d_unmap_ioport (between 'asd_unmap_ha' and 'asd_remove_dev_attrs')
WARNING: vmlinux.o(.text+0x1ec8b1): Section mismatch: reference to .exit.text:as
d_unmap_memio (between 'asd_unmap_ha' and 'asd_remove_dev_attrs')

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
