/* * Fast C2P (Chunky-to-Planar) Conversion * * Copyright (C) 2003-2008 Geert Uytterhoeven * * This file is subject to the terms and conditions of the GNU General Public * License. See the file COPYING in the main directory of this archive * for more details. */ #include #include #include #include "c2p.h" #include "c2p_core.h" /* * Perform a full C2P step on 32 8-bit pixels, stored in 8 32-bit words * containing * - 32 8-bit chunky pixels on input * - permutated planar data (1 plane per 32-bit word) on output */ static void c2p_32x8(u32 d[8]) { transp8(d, 16, 4); transp8(d, 8, 2); transp8(d, 4, 1); transp8(d, 2, 4); transp8(d, 1, 2); } /* * Array containing the permutation indices of the planar data after c2p */ static const int perm_c2p_32x8[8] = { 7, 5, 3, 1, 6, 4, 2, 0 }; /* * Store a full block of planar data after c2p conversion */ static inline void store_planar(void *dst, u32 dst_inc, u32 bpp, u32 d[8]) { int i; for (i = 0; i < bpp; i++, dst += dst_inc) put_unaligned_be32(d[perm_c2p_32x8[i]], dst); } /* * Store a partial block of planar data after c2p conversion */ static inline void store_planar_masked(void *dst, u32 dst_inc, u32 bpp, u32 d[8], u32 mask) { int i; for (i = 0; i < bpp; i++, dst += dst_inc) put_unaligned_be32(comp(d[perm_c2p_32x8[i]], get_unaligned_be32(dst), mask), dst); } /* * c2p_planar - Copy 8-bit chunky image data to a planar frame buffer * @dst: Starting address of the planar frame buffer * @dx: Horizontal destination offset (in pixels) * @dy: Vertical destination offset (in pixels) * @width: Image width (in pixels) * @height: Image height (in pixels) * @dst_nextline: Frame buffer offset to the next line (in bytes) * @dst_nextplane: Frame buffer offset to the next plane (in bytes) * @src_nextline: Image offset to the next line (in bytes) * @bpp: Bits per pixel of the planar frame buffer (1-8) */ void c2p_planar(void *dst, const void *src, u32 dx, u32 dy, u32 width, u32 height, u32 dst_nextline, u32 dst_nextplane, u32 src_nextline, u32 bpp) { union { u8 pixels[32]; u32 words[8]; } d; u32 dst_idx, first, last, w; const u8 *c; void *p; dst += dy*dst_nextline+(dx & ~31); dst_idx = dx % 32; first = 0xffffffffU >> dst_idx; last = ~(0xffffffffU >> ((dst_idx+width) % 32)); while (height--) { c = src; p = dst; w = width; if (dst_idx+width <= 32) { /* Single destination word */ first &= last; memset(d.pixels, 0, sizeof(d)); memcpy(d.pixels+dst_idx, c, width); c += width; c2p_32x8(d.words); store_planar_masked(p, dst_nextplane, bpp, d.words, first); p += 4; } else { /* Multiple destination words */ w = width; /* Leading bits */ if (dst_idx) { w = 32 - dst_idx; memset(d.pixels, 0, dst_idx); memcpy(d.pixels+dst_idx, c, w); c += w; c2p_32x8(d.words); store_planar_masked(p, dst_nextplane, bpp, d.words, first); p += 4; w = width-w; } /* Main chunk */ while (w >= 32) { memcpy(d.pixels, c, 32); c += 32; c2p_32x8(d.words); store_planar(p, dst_nextplane, bpp, d.words); p += 4; w -= 32; } /* Trailing bits */ w %= 32; if (w > 0) { memcpy(d.pixels, c, w); memset(d.pixels+w, 0, 32-w); c2p_32x8(d.words); store_planar_masked(p, dst_nextplane, bpp, d.words, last); } } src += src_nextline; dst += dst_nextline; } } EXPORT_SYMBOL_GPL(c2p_planar); MODULE_LICENSE("GPL"); elected='selected'>3space:mode:
authorBenjamin Herrenschmidt <benh@kernel.crashing.org>2017-02-03 17:10:28 +1100
committerMichael Ellerman <mpe@ellerman.id.au>2017-02-08 23:36:29 +1100
commitd7df2443cd5f67fc6ee7c05a88e4996e8177f91b (patch)
tree098a7c0ca4fceb8a65cb1f693c9d71990388933d /include/uapi/sound/sfnt_info.h
parenta0615a16f7d0ceb5804d295203c302d496d8ee91 (diff)
powerpc/mm: Fix spurrious segfaults on radix with autonuma
When autonuma (Automatic NUMA balancing) marks a PTE inaccessible it clears all the protection bits but leave the PTE valid. With the Radix MMU, an attempt at executing from such a PTE will take a fault with bit 35 of SRR1 set "SRR1_ISI_N_OR_G". It is thus incorrect to treat all such faults as errors. We should pass them to handle_mm_fault() for autonuma to deal with. The case of pages that are really not executable is handled by the existing test for VM_EXEC further down. That leaves us with catching the kernel attempts at executing user pages. We can catch that earlier, even before we do find_vma. It is never valid on powerpc for the kernel to take an exec fault to begin with. So fold that test with the existing test for the kernel faulting on kernel addresses to bail out early. Fixes: 1d18ad026844 ("powerpc/mm: Detect instruction fetch denied and report") Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org> Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> Acked-by: Balbir Singh <bsingharora@gmail.com> Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Diffstat (limited to 'include/uapi/sound/sfnt_info.h')