tree 171068cd7d99600cd094c2eb72bac712649fd9eb
parent 11c3e689f1c3a73e3af7b0ea767b1b0626da8033
author James Bottomley <James.Bottomley@HansenPartnership.com> 1199203210 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1200097762 -0600

[SCSI] relax scsi dma alignment

This patch relaxes the default SCSI DMA alignment from 512 bytes to 4
bytes.  I remember from previous discussions that usb and firewire have
sector size alignment requirements, so I upped their alignments in the
respective slave allocs.

The reason for doing this is so that we don't get such a huge amount of
copy overhead in bio_copy_user() for udev.  (basically all inquiries it
issues can now be directly mapped).

Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
