linuxkpi: Fix `sg_alloc_table_from_pages()` to have the same API as Linux

[dumbbell]

Summary

It now returns a struct scatterlist * pointer instead of an error code only.

The implementation is incomplete because it doesn't use the prv argument.

This is part of the update of the DRM drivers to Linux 5.13.

[dumbbell]

Support old and new __sg_alloc_table_from_pages() API.

sys/compat/linuxkpi/common/include/linux/scatterlist.h

sg_alloc_table(struct sg_table *table, unsigned int nents, gfp_t gfp_mask)
         ret = __sg_alloc_table(table, nents, SG_MAX_SINGLE_ALLOC,
             NULL, gfp_mask, sg_kmalloc);
         if (unlikely(ret))
                 __sg_free_table(table, SG_MAX_SINGLE_ALLOC, 0, sg_kfree);
 
         return (ret);
 }
 
+#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
+static inline struct scatterlist *
+__sg_alloc_table_from_pages(struct sg_table *sgt,
+    struct page **pages, unsigned int count,
+    unsigned long off, unsigned long size,
+    unsigned int max_segment,
+    struct scatterlist *prv, unsigned int left_pages,
+    gfp_t gfp_mask)
+#else
 static inline int
 __sg_alloc_table_from_pages(struct sg_table *sgt,
     struct page **pages, unsigned int count,
     unsigned long off, unsigned long size,
     unsigned int max_segment, gfp_t gfp_mask)
+#endif
 {
         unsigned int i, segs, cur, len;
         int rc;
         struct scatterlist *s;
 
+#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
+        if (prv != NULL) {
+                panic(
+                    "Support for prv != NULL not implemented in "
+                    "__sg_alloc_table_from_pages()");
+        }
+#endif
+
         if (__predict_false(!max_segment || offset_in_page(max_segment)))
+#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
+                return (ERR_PTR(-EINVAL));
+#else
                 return (-EINVAL);
+#endif
 
         len = 0;
         for (segs = i = 1; i < count; ++i) {
                 len += PAGE_SIZE;
                 if (len >= max_segment ||
                     page_to_pfn(pages[i]) != page_to_pfn(pages[i - 1]) + 1) {
                         ++segs;
                         len = 0;
                 }
         }
         if (__predict_false((rc = sg_alloc_table(sgt, segs, gfp_mask))))
+#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
+                return (ERR_PTR(rc));
+#else
                 return (rc);
+#endif
 
         cur = 0;
-        for_each_sg(sgt->sgl, s, sgt->orig_nents, i) {
+        for (i = 0, s = sgt->sgl; i < sgt->orig_nents; i++) {
                 unsigned long seg_size;
                 unsigned int j;
 
+                s = sg_next(s);
+
                 len = 0;
                 for (j = cur + 1; j < count; ++j) {
                         len += PAGE_SIZE;
                         if (len >= max_segment || page_to_pfn(pages[j]) !=
                             page_to_pfn(pages[j - 1]) + 1)
                                 break;
                 }
 
                 seg_size = ((j - cur) << PAGE_SHIFT) - off;
                 sg_set_page(s, pages[cur], MIN(size, seg_size), off);
                 size -= seg_size;
                 off = 0;
                 cur = j;
         }
+        KASSERT(s != NULL, ("s is NULL after loop in __sg_alloc_table_from_pages()"));
+
+#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
+        if (left_pages == 0)
+                sg_mark_end(s);
+
+        return (s);
+#else
         return (0);
+#endif
 }
 
 static inline int
 sg_alloc_table_from_pages(struct sg_table *sgt,
     struct page **pages, unsigned int count,
     unsigned long off, unsigned long size,
     gfp_t gfp_mask)
 {
 
+#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
+        return (PTR_ERR_OR_ZERO(__sg_alloc_table_from_pages(sgt, pages, count, off, size,
+            SCATTERLIST_MAX_SEGMENT, NULL, 0, gfp_mask)));
+#else
         return (__sg_alloc_table_from_pages(sgt, pages, count, off, size,
             SCATTERLIST_MAX_SEGMENT, gfp_mask));
+#endif
 }
 
 static inline int
 sg_nents(struct scatterlist *sg)
 {
         int nents;
 
         for (nents = 0; sg; sg = sg_next(sg))