10 files changed, 223 insertions, 102 deletions

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 1cb74085e410..8baff0effc7d 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -300,8 +300,8 @@ config SGI_GRU_DEBUG
         depends on SGI_GRU
         default n
         ---help---
-        This option enables addition debugging code for the SGI GRU driver. If
-        you are unsure, say N.
+        This option enables additional debugging code for the SGI GRU driver.
+        If you are unsure, say N.
 
 config APDS9802ALS
         tristate "Medfield Avago APDS9802 ALS Sensor module"
diff --git a/drivers/misc/genwqe/card_base.h b/drivers/misc/genwqe/card_base.h
index 5e4dbd21f89a..0e608a288603 100644
--- a/drivers/misc/genwqe/card_base.h
+++ b/drivers/misc/genwqe/card_base.h
@@ -337,6 +337,44 @@ enum genwqe_requ_state {
 };
 
 /**
+ * struct genwqe_sgl - Scatter gather list describing user-space memory
+ * @sgl:            scatter gather list needs to be 128 byte aligned
+ * @sgl_dma_addr:   dma address of sgl
+ * @sgl_size:       size of area used for sgl
+ * @user_addr:      user-space address of memory area
+ * @user_size:      size of user-space memory area
+ * @page:           buffer for partial pages if needed
+ * @page_dma_addr:  dma address partial pages
+ */
+struct genwqe_sgl {
+        dma_addr_t sgl_dma_addr;
+        struct sg_entry *sgl;
+        size_t sgl_size;        /* size of sgl */
+
+        void __user *user_addr; /* user-space base-address */
+        size_t user_size;       /* size of memory area */
+
+        unsigned long nr_pages;
+        unsigned long fpage_offs;
+        size_t fpage_size;
+        size_t lpage_size;
+
+        void *fpage;
+        dma_addr_t fpage_dma_addr;
+
+        void *lpage;
+        dma_addr_t lpage_dma_addr;
+};
+
+int genwqe_alloc_sync_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl,
+                          void __user *user_addr, size_t user_size);
+
+int genwqe_setup_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl,
+                     dma_addr_t *dma_list);
+
+int genwqe_free_sync_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl);
+
+/**
  * struct ddcb_requ - Kernel internal representation of the DDCB request
  * @cmd:          User space representation of the DDCB execution request
  */
@@ -347,9 +385,7 @@ struct ddcb_requ {
         struct ddcb_queue *queue;         /* associated queue */
 
         struct dma_mapping  dma_mappings[DDCB_FIXUPS];
-        struct sg_entry     *sgl[DDCB_FIXUPS];
-        dma_addr_t          sgl_dma_addr[DDCB_FIXUPS];
-        size_t              sgl_size[DDCB_FIXUPS];
+        struct genwqe_sgl sgls[DDCB_FIXUPS];
 
         /* kernel/user shared content */
         struct genwqe_ddcb_cmd cmd;     /* ddcb_no for this request */
@@ -453,22 +489,6 @@ int  genwqe_user_vmap(struct genwqe_dev *cd, struct dma_mapping *m,
 int  genwqe_user_vunmap(struct genwqe_dev *cd, struct dma_mapping *m,
                         struct ddcb_requ *req);
 
-struct sg_entry *genwqe_alloc_sgl(struct genwqe_dev *cd, int num_pages,
-                                 dma_addr_t *dma_addr, size_t *sgl_size);
-
-void genwqe_free_sgl(struct genwqe_dev *cd, struct sg_entry *sg_list,
-                    dma_addr_t dma_addr, size_t size);
-
-int genwqe_setup_sgl(struct genwqe_dev *cd,
-                    unsigned long offs,
-                    unsigned long size,
-                    struct sg_entry *sgl, /* genwqe sgl */
-                    dma_addr_t dma_addr, size_t sgl_size,
-                    dma_addr_t *dma_list, int page_offs, int num_pages);
-
-int genwqe_check_sgl(struct genwqe_dev *cd, struct sg_entry *sg_list,
-                     int size);
-
 static inline bool dma_mapping_used(struct dma_mapping *m)
 {
         if (!m)
diff --git a/drivers/misc/genwqe/card_ddcb.c b/drivers/misc/genwqe/card_ddcb.c
index 6f1acc0ccf88..c8046db2d5a2 100644
--- a/drivers/misc/genwqe/card_ddcb.c
+++ b/drivers/misc/genwqe/card_ddcb.c
@@ -305,6 +305,8 @@ static int enqueue_ddcb(struct genwqe_dev *cd, struct ddcb_queue *queue,
                         break;
 
                 new = (old | DDCB_NEXT_BE32);
+
+                wmb();
                 icrc_hsi_shi = cmpxchg(&prev_ddcb->icrc_hsi_shi_32, old, new);
 
                 if (icrc_hsi_shi == old)
@@ -314,6 +316,8 @@ static int enqueue_ddcb(struct genwqe_dev *cd, struct ddcb_queue *queue,
         /* Queue must be re-started by updating QUEUE_OFFSET */
         ddcb_mark_tapped(pddcb);
         num = (u64)ddcb_no << 8;
+
+        wmb();
         __genwqe_writeq(cd, queue->IO_QUEUE_OFFSET, num); /* start queue */
 
         return RET_DDCB_TAPPED;
@@ -1306,7 +1310,7 @@ static int queue_wake_up_all(struct genwqe_dev *cd)
  */
 int genwqe_finish_queue(struct genwqe_dev *cd)
 {
-        int i, rc, in_flight;
+        int i, rc = 0, in_flight;
         int waitmax = genwqe_ddcb_software_timeout;
         struct pci_dev *pci_dev = cd->pci_dev;
         struct ddcb_queue *queue = &cd->queue;
diff --git a/drivers/misc/genwqe/card_dev.c b/drivers/misc/genwqe/card_dev.c
index 2c2c9cc75231..1d2f163a1906 100644
--- a/drivers/misc/genwqe/card_dev.c
+++ b/drivers/misc/genwqe/card_dev.c
@@ -531,7 +531,9 @@ static int do_flash_update(struct genwqe_file *cfile,
         case '1':
                 cmdopts = 0x1C;
                 break;          /* download/erase_first/part_1 */
-        case 'v':               /* cmdopts = 0x0c (VPD) */
+        case 'v':
+                cmdopts = 0x0C;
+                break;          /* download/erase_first/vpd */
         default:
                 return -EINVAL;
         }
@@ -665,6 +667,8 @@ static int do_flash_read(struct genwqe_file *cfile,
                 cmdopts = 0x1A;
                 break;          /* upload/part_1 */
         case 'v':
+                cmdopts = 0x0A;
+                break;          /* upload/vpd */
         default:
                 return -EINVAL;
         }
@@ -836,15 +840,8 @@ static int ddcb_cmd_cleanup(struct genwqe_file *cfile, struct ddcb_requ *req)
                         __genwqe_del_mapping(cfile, dma_map);
                         genwqe_user_vunmap(cd, dma_map, req);
                 }
-                if (req->sgl[i] != NULL) {
-                        genwqe_free_sgl(cd, req->sgl[i],
-                                       req->sgl_dma_addr[i],
-                                       req->sgl_size[i]);
-                        req->sgl[i] = NULL;
-                        req->sgl_dma_addr[i] = 0x0;
-                        req->sgl_size[i] = 0;
-                }
-
+                if (req->sgls[i].sgl != NULL)
+                        genwqe_free_sync_sgl(cd, &req->sgls[i]);
         }
         return 0;
 }
@@ -913,7 +910,7 @@ static int ddcb_cmd_fixups(struct genwqe_file *cfile, struct ddcb_requ *req)
 
                 case ATS_TYPE_SGL_RDWR:
                 case ATS_TYPE_SGL_RD: {
-                        int page_offs, nr_pages, offs;
+                        int page_offs;
 
                         u_addr = be64_to_cpu(*((__be64 *)
                                                &cmd->asiv[asiv_offs]));
@@ -951,27 +948,18 @@ static int ddcb_cmd_fixups(struct genwqe_file *cfile, struct ddcb_requ *req)
                                 page_offs = 0;
                         }
 
-                        offs = offset_in_page(u_addr);
-                        nr_pages = DIV_ROUND_UP(offs + u_size, PAGE_SIZE);
-
                         /* create genwqe style scatter gather list */
-                        req->sgl[i] = genwqe_alloc_sgl(cd, m->nr_pages,
-                                                      &req->sgl_dma_addr[i],
-                                                      &req->sgl_size[i]);
-                        if (req->sgl[i] == NULL) {
-                                rc = -ENOMEM;
+                        rc = genwqe_alloc_sync_sgl(cd, &req->sgls[i],
+                                                   (void __user *)u_addr,
+                                                   u_size);
+                        if (rc != 0)
                                 goto err_out;
-                        }
-                        genwqe_setup_sgl(cd, offs, u_size,
-                                        req->sgl[i],
-                                        req->sgl_dma_addr[i],
-                                        req->sgl_size[i],
-                                        m->dma_list,
-                                        page_offs,
-                                        nr_pages);
+
+                        genwqe_setup_sgl(cd, &req->sgls[i],
+                                         &m->dma_list[page_offs]);
 
                         *((__be64 *)&cmd->asiv[asiv_offs]) =
-                                cpu_to_be64(req->sgl_dma_addr[i]);
+                                cpu_to_be64(req->sgls[i].sgl_dma_addr);
 
                         break;
                 }
diff --git a/drivers/misc/genwqe/card_utils.c b/drivers/misc/genwqe/card_utils.c
index 6b1a6ef9f1a8..d049d271699c 100644
--- a/drivers/misc/genwqe/card_utils.c
+++ b/drivers/misc/genwqe/card_utils.c
@@ -275,67 +275,107 @@ static int genwqe_sgl_size(int num_pages)
         return roundup(len, PAGE_SIZE);
 }
 
-struct sg_entry *genwqe_alloc_sgl(struct genwqe_dev *cd, int num_pages,
-                                  dma_addr_t *dma_addr, size_t *sgl_size)
+/**
+ * genwqe_alloc_sync_sgl() - Allocate memory for sgl and overlapping pages
+ *
+ * Allocates memory for sgl and overlapping pages. Pages which might
+ * overlap other user-space memory blocks are being cached for DMAs,
+ * such that we do not run into syncronization issues. Data is copied
+ * from user-space into the cached pages.
+ */
+int genwqe_alloc_sync_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl,
+                          void __user *user_addr, size_t user_size)
 {
+        int rc;
         struct pci_dev *pci_dev = cd->pci_dev;
-        struct sg_entry *sgl;
 
-        *sgl_size = genwqe_sgl_size(num_pages);
-        if (get_order(*sgl_size) > MAX_ORDER) {
+        sgl->fpage_offs = offset_in_page((unsigned long)user_addr);
+        sgl->fpage_size = min_t(size_t, PAGE_SIZE-sgl->fpage_offs, user_size);
+        sgl->nr_pages = DIV_ROUND_UP(sgl->fpage_offs + user_size, PAGE_SIZE);
+        sgl->lpage_size = (user_size - sgl->fpage_size) % PAGE_SIZE;
+
+        dev_dbg(&pci_dev->dev, "[%s] uaddr=%p usize=%8ld nr_pages=%ld "
+                "fpage_offs=%lx fpage_size=%ld lpage_size=%ld\n",
+                __func__, user_addr, user_size, sgl->nr_pages,
+                sgl->fpage_offs, sgl->fpage_size, sgl->lpage_size);
+
+        sgl->user_addr = user_addr;
+        sgl->user_size = user_size;
+        sgl->sgl_size = genwqe_sgl_size(sgl->nr_pages);
+
+        if (get_order(sgl->sgl_size) > MAX_ORDER) {
                 dev_err(&pci_dev->dev,
                         "[%s] err: too much memory requested!\n", __func__);
-                return NULL;
+                return -ENOMEM;
         }
 
-        sgl = __genwqe_alloc_consistent(cd, *sgl_size, dma_addr);
-        if (sgl == NULL) {
+        sgl->sgl = __genwqe_alloc_consistent(cd, sgl->sgl_size,
+                                             &sgl->sgl_dma_addr);
+        if (sgl->sgl == NULL) {
                 dev_err(&pci_dev->dev,
                         "[%s] err: no memory available!\n", __func__);
-                return NULL;
+                return -ENOMEM;
         }
 
-        return sgl;
+        /* Only use buffering on incomplete pages */
+        if ((sgl->fpage_size != 0) && (sgl->fpage_size != PAGE_SIZE)) {
+                sgl->fpage = __genwqe_alloc_consistent(cd, PAGE_SIZE,
+                                                       &sgl->fpage_dma_addr);
+                if (sgl->fpage == NULL)
+                        goto err_out;
+
+                /* Sync with user memory */
+                if (copy_from_user(sgl->fpage + sgl->fpage_offs,
+                                   user_addr, sgl->fpage_size)) {
+                        rc = -EFAULT;
+                        goto err_out;
+                }
+        }
+        if (sgl->lpage_size != 0) {
+                sgl->lpage = __genwqe_alloc_consistent(cd, PAGE_SIZE,
+                                                       &sgl->lpage_dma_addr);
+                if (sgl->lpage == NULL)
+                        goto err_out1;
+
+                /* Sync with user memory */
+                if (copy_from_user(sgl->lpage, user_addr + user_size -
+                                   sgl->lpage_size, sgl->lpage_size)) {
+                        rc = -EFAULT;
+                        goto err_out1;
+                }
+        }
+        return 0;
+
+ err_out1:
+        __genwqe_free_consistent(cd, PAGE_SIZE, sgl->fpage,
+                                 sgl->fpage_dma_addr);
+ err_out:
+        __genwqe_free_consistent(cd, sgl->sgl_size, sgl->sgl,
+                                 sgl->sgl_dma_addr);
+        return -ENOMEM;
 }
 
-int genwqe_setup_sgl(struct genwqe_dev *cd,
-                     unsigned long offs,
-                     unsigned long size,
-                     struct sg_entry *sgl,
-                     dma_addr_t dma_addr, size_t sgl_size,
-                     dma_addr_t *dma_list, int page_offs, int num_pages)
+int genwqe_setup_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl,
+                     dma_addr_t *dma_list)
 {
         int i = 0, j = 0, p;
         unsigned long dma_offs, map_offs;
-        struct pci_dev *pci_dev = cd->pci_dev;
         dma_addr_t prev_daddr = 0;
         struct sg_entry *s, *last_s = NULL;
-
-        /* sanity checks */
-        if (offs > PAGE_SIZE) {
-                dev_err(&pci_dev->dev,
-                        "[%s] too large start offs %08lx\n", __func__, offs);
-                return -EFAULT;
-        }
-        if (sgl_size < genwqe_sgl_size(num_pages)) {
-                dev_err(&pci_dev->dev,
-                        "[%s] sgl_size too small %08lx for %d pages\n",
-                        __func__, sgl_size, num_pages);
-                return -EFAULT;
-        }
+        size_t size = sgl->user_size;
 
         dma_offs = 128;         /* next block if needed/dma_offset */
-        map_offs = offs;        /* offset in first page */
+        map_offs = sgl->fpage_offs; /* offset in first page */
 
-        s = &sgl[0];            /* first set of 8 entries */
+        s = &sgl->sgl[0];       /* first set of 8 entries */
         p = 0;                  /* page */
-        while (p < num_pages) {
+        while (p < sgl->nr_pages) {
                 dma_addr_t daddr;
                 unsigned int size_to_map;
 
                 /* always write the chaining entry, cleanup is done later */
                 j = 0;
-                s[j].target_addr = cpu_to_be64(dma_addr + dma_offs);
+                s[j].target_addr = cpu_to_be64(sgl->sgl_dma_addr + dma_offs);
                 s[j].len         = cpu_to_be32(128);
                 s[j].flags       = cpu_to_be32(SG_CHAINED);
                 j++;
@@ -343,7 +383,17 @@ int genwqe_setup_sgl(struct genwqe_dev *cd,
                 while (j < 8) {
                         /* DMA mapping for requested page, offs, size */
                         size_to_map = min(size, PAGE_SIZE - map_offs);
-                        daddr = dma_list[page_offs + p] + map_offs;
+
+                        if ((p == 0) && (sgl->fpage != NULL)) {
+                                daddr = sgl->fpage_dma_addr + map_offs;
+
+                        } else if ((p == sgl->nr_pages - 1) &&
+                                   (sgl->lpage != NULL)) {
+                                daddr = sgl->lpage_dma_addr;
+                        } else {
+                                daddr = dma_list[p] + map_offs;
+                        }
+
                         size -= size_to_map;
                         map_offs = 0;
 
@@ -358,7 +408,7 @@ int genwqe_setup_sgl(struct genwqe_dev *cd,
                                                           size_to_map);
 
                                 p++; /* process next page */
-                                if (p == num_pages)
+                                if (p == sgl->nr_pages)
                                         goto fixup;  /* nothing to do */
 
                                 prev_daddr = daddr + size_to_map;
@@ -374,7 +424,7 @@ int genwqe_setup_sgl(struct genwqe_dev *cd,
                         j++;
 
                         p++;    /* process next page */
-                        if (p == num_pages)
+                        if (p == sgl->nr_pages)
                                 goto fixup;  /* nothing to do */
                 }
                 dma_offs += 128;
@@ -395,10 +445,50 @@ int genwqe_setup_sgl(struct genwqe_dev *cd,
         return 0;
 }
 
-void genwqe_free_sgl(struct genwqe_dev *cd, struct sg_entry *sg_list,
-                    dma_addr_t dma_addr, size_t size)
+/**
+ * genwqe_free_sync_sgl() - Free memory for sgl and overlapping pages
+ *
+ * After the DMA transfer has been completed we free the memory for
+ * the sgl and the cached pages. Data is being transfered from cached
+ * pages into user-space buffers.
+ */
+int genwqe_free_sync_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl)
 {
-        __genwqe_free_consistent(cd, size, sg_list, dma_addr);
+        int rc;
+        struct pci_dev *pci_dev = cd->pci_dev;
+
+        if (sgl->fpage) {
+                if (copy_to_user(sgl->user_addr, sgl->fpage + sgl->fpage_offs,
+                                 sgl->fpage_size)) {
+                        dev_err(&pci_dev->dev, "[%s] err: copying fpage!\n",
+                                __func__);
+                        rc = -EFAULT;
+                }
+                __genwqe_free_consistent(cd, PAGE_SIZE, sgl->fpage,
+                                         sgl->fpage_dma_addr);
+                sgl->fpage = NULL;
+                sgl->fpage_dma_addr = 0;
+        }
+        if (sgl->lpage) {
+                if (copy_to_user(sgl->user_addr + sgl->user_size -
+                                 sgl->lpage_size, sgl->lpage,
+                                 sgl->lpage_size)) {
+                        dev_err(&pci_dev->dev, "[%s] err: copying lpage!\n",
+                                __func__);
+                        rc = -EFAULT;
+                }
+                __genwqe_free_consistent(cd, PAGE_SIZE, sgl->lpage,
+                                         sgl->lpage_dma_addr);
+                sgl->lpage = NULL;
+                sgl->lpage_dma_addr = 0;
+        }
+        __genwqe_free_consistent(cd, sgl->sgl_size, sgl->sgl,
+                                 sgl->sgl_dma_addr);
+
+        sgl->sgl = NULL;
+        sgl->sgl_dma_addr = 0x0;
+        sgl->sgl_size = 0;
+        return rc;
 }
 
 /**
diff --git a/drivers/misc/genwqe/genwqe_driver.h b/drivers/misc/genwqe/genwqe_driver.h
index 46e916b36c70..cd5263163a6e 100644
--- a/drivers/misc/genwqe/genwqe_driver.h
+++ b/drivers/misc/genwqe/genwqe_driver.h
@@ -36,7 +36,7 @@
 #include <asm/byteorder.h>
 #include <linux/genwqe/genwqe_card.h>
 
-#define DRV_VERS_STRING         "2.0.0"
+#define DRV_VERS_STRING         "2.0.15"
 
 /*
  * Static minor number assignement, until we decide/implement
diff --git a/drivers/misc/mei/hw-me-regs.h b/drivers/misc/mei/hw-me-regs.h
index 66f411a6e8ea..cabc04383685 100644
--- a/drivers/misc/mei/hw-me-regs.h
+++ b/drivers/misc/mei/hw-me-regs.h
@@ -115,6 +115,11 @@
 #define MEI_DEV_ID_LPT_HR     0x8CBA  /* Lynx Point H Refresh */
 
 #define MEI_DEV_ID_WPT_LP     0x9CBA  /* Wildcat Point LP */
+
+/* Host Firmware Status Registers in PCI Config Space */
+#define PCI_CFG_HFS_1         0x40
+#define PCI_CFG_HFS_2         0x48
+
 /*
  * MEI HW Section
  */
diff --git a/drivers/misc/mei/interrupt.c b/drivers/misc/mei/interrupt.c
index 29b5af8efb71..4e3cba6da3f5 100644
--- a/drivers/misc/mei/interrupt.c
+++ b/drivers/misc/mei/interrupt.c
@@ -455,8 +455,7 @@ int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list)
 
                 cl->status = 0;
                 list_del(&cb->list);
-                if (MEI_WRITING == cl->writing_state &&
-                    cb->fop_type == MEI_FOP_WRITE &&
+                if (cb->fop_type == MEI_FOP_WRITE &&
                     cl != &dev->iamthif_cl) {
                         cl_dbg(dev, cl, "MEI WRITE COMPLETE\n");
                         cl->writing_state = MEI_WRITE_COMPLETE;
diff --git a/drivers/misc/mei/main.c b/drivers/misc/mei/main.c
index b35594dbf52f..147413145c97 100644
--- a/drivers/misc/mei/main.c
+++ b/drivers/misc/mei/main.c
@@ -644,8 +644,7 @@ static unsigned int mei_poll(struct file *file, poll_table *wait)
                 goto out;
         }
 
-        if (MEI_WRITE_COMPLETE == cl->writing_state)
-                mask |= (POLLIN | POLLRDNORM);
+        mask |= (POLLIN | POLLRDNORM);
 
 out:
         mutex_unlock(&dev->device_lock);
diff --git a/drivers/misc/mei/pci-me.c b/drivers/misc/mei/pci-me.c
index 1c8fd3a3e135..95889e2e31ff 100644
--- a/drivers/misc/mei/pci-me.c
+++ b/drivers/misc/mei/pci-me.c
@@ -97,15 +97,31 @@ static bool mei_me_quirk_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *ent)
 {
         u32 reg;
-        if (ent->device == MEI_DEV_ID_PBG_1) {
-                pci_read_config_dword(pdev, 0x48, &reg);
-                /* make sure that bit 9 is up and bit 10 is down */
-                if ((reg & 0x600) == 0x200) {
-                        dev_info(&pdev->dev, "Device doesn't have valid ME Interface\n");
-                        return false;
-                }
+        /* Cougar Point || Patsburg */
+        if (ent->device == MEI_DEV_ID_CPT_1 ||
+            ent->device == MEI_DEV_ID_PBG_1) {
+                pci_read_config_dword(pdev, PCI_CFG_HFS_2, &reg);
+                /* make sure that bit 9 (NM) is up and bit 10 (DM) is down */
+                if ((reg & 0x600) == 0x200)
+                        goto no_mei;
         }
+
+        /* Lynx Point */
+        if (ent->device == MEI_DEV_ID_LPT_H  ||
+            ent->device == MEI_DEV_ID_LPT_W  ||
+            ent->device == MEI_DEV_ID_LPT_HR) {
+                /* Read ME FW Status check for SPS Firmware */
+                pci_read_config_dword(pdev, PCI_CFG_HFS_1, &reg);
+                /* if bits [19:16] = 15, running SPS Firmware */
+                if ((reg & 0xf0000) == 0xf0000)
+                        goto no_mei;
+        }
+
         return true;
+
+no_mei:
+        dev_info(&pdev->dev, "Device doesn't have valid ME Interface\n");
+        return false;
 }
 /**
  * mei_probe - Device Initialization Routine