tree 4eb14ace67f773a18e6f712304d0b7aa1ac1f9ee
parent 279e7f5425c5e6da6ca61b1d8576356a939789f9
author James Bottomley <James.Bottomley@HansenPartnership.com> 1203269091 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1203346945 -0600

[SCSI] gdth: don't call pci_free_consistent under spinlock

The spinlock is held over too large a region: pscratch is a permanent
address (it's allocated at boot time and never changes).  All you need
the smp lock for is mediating the scratch in use flag, so fix this by
moving the spinlock into the case where we set the pscratch_busy flag
to false.

Cc: Stable Tree <stable@kernel.org>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
