[SCSI] dc395x: dynamically map scatter-gather for PIO

The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.

The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.

There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...

Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.

Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

1 files changed, 57 insertions, 0 deletions

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 7b0f9a3810d2..57453ca09700 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -2350,3 +2350,60 @@ scsi_target_unblock(struct device *dev)
                 device_for_each_child(dev, NULL, target_unblock);
 }
 EXPORT_SYMBOL_GPL(scsi_target_unblock);
+
+/**
+ * scsi_kmap_atomic_sg - find and atomically map an sg-elemnt
+ * @sg:         scatter-gather list
+ * @sg_count:   number of segments in sg
+ * @offset:     offset in bytes into sg, on return offset into the mapped area
+ * @len:        bytes to map, on return number of bytes mapped
+ *
+ * Returns virtual address of the start of the mapped page
+ */
+void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
+                          size_t *offset, size_t *len)
+{
+        int i;
+        size_t sg_len = 0, len_complete = 0;
+        struct page *page;
+
+        for (i = 0; i < sg_count; i++) {
+                len_complete = sg_len; /* Complete sg-entries */
+                sg_len += sg[i].length;
+                if (sg_len > *offset)
+                        break;
+        }
+
+        if (unlikely(i == sg_count)) {
+                printk(KERN_ERR "%s: Bytes in sg: %u, requested offset %u, elements %d\n",
+                       __FUNCTION__, sg_len, *offset, sg_count);
+                WARN_ON(1);
+                return NULL;
+        }
+
+        /* Offset starting from the beginning of first page in this sg-entry */
+        *offset = *offset - len_complete + sg[i].offset;
+
+        /* Assumption: contiguous pages can be accessed as "page + i" */
+        page = nth_page(sg[i].page, (*offset >> PAGE_SHIFT));
+        *offset &= ~PAGE_MASK;
+
+        /* Bytes in this sg-entry from *offset to the end of the page */
+        sg_len = PAGE_SIZE - *offset;
+        if (*len > sg_len)
+                *len = sg_len;
+
+        return kmap_atomic(page, KM_BIO_SRC_IRQ);
+}
+EXPORT_SYMBOL(scsi_kmap_atomic_sg);
+
+/**
+ * scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously
+ *                         mapped with scsi_kmap_atomic_sg
+ * @virt:       virtual address to be unmapped
+ */
+void scsi_kunmap_atomic_sg(void *virt)
+{
+        kunmap_atomic(virt, KM_BIO_SRC_IRQ);
+}
+EXPORT_SYMBOL(scsi_kunmap_atomic_sg);