target/linux/ubicom32/files/arch/ubicom32/include/asm/checksum.h

   1 /*
   2  * arch/ubicom32/include/asm/checksum.h
   3  *   Checksum utilities for Ubicom32 architecture.
   4  *
   5  * (C) Copyright 2009, Ubicom, Inc.
   6  *
   7  * This file is part of the Ubicom32 Linux Kernel Port.
   8  *
   9  * The Ubicom32 Linux Kernel Port is free software: you can redistribute
  10  * it and/or modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation, either version 2 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * The Ubicom32 Linux Kernel Port is distributed in the hope that it
  15  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  16  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  * the GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with the Ubicom32 Linux Kernel Port.  If not,
  21  * see <http://www.gnu.org/licenses/>.
  22  *
  23  * Ubicom32 implementation derived from (with many thanks):
  24  *   arch/m68knommu
  25  *   arch/blackfin
  26  *   arch/parisc
  27  */
  28 #ifndef _ASM_UBICOM32_CHECKSUM_H
  29 #define _ASM_UBICOM32_CHECKSUM_H
  30
  31 #include <linux/in6.h>
  32
  33 /*
  34  * computes the checksum of a memory block at buff, length len,
  35  * and adds in "sum" (32-bit)
  36  *
  37  * returns a 32-bit number suitable for feeding into itself
  38  * or csum_tcpudp_magic
  39  *
  40  * this function must be called with even lengths, except
  41  * for the last fragment, which may be odd
  42  *
  43  * it's best to have buff aligned on a 32-bit boundary
  44  */
  45 __wsum csum_partial(const void *buff, int len, __wsum sum);
  46
  47 /*
  48  * the same as csum_partial, but copies from src while it
  49  * checksums
  50  *
  51  * here even more important to align src and dst on a 32-bit (or even
  52  * better 64-bit) boundary
  53  */
  54
  55 __wsum csum_partial_copy_nocheck(const void *src, void *dst,
  56         int len, __wsum sum);
  57
  58
  59 /*
  60  * the same as csum_partial_copy, but copies from user space.
  61  *
  62  * here even more important to align src and dst on a 32-bit (or even
  63  * better 64-bit) boundary
  64  */
  65
  66 extern __wsum csum_partial_copy_from_user(const void __user *src,
  67         void *dst, int len, __wsum sum, int *csum_err);
  68
  69 __sum16 ip_fast_csum(const void *iph, unsigned int ihl);
  70
  71 /*
  72  *      Fold a partial checksum
  73  */
  74
  75 static inline __sum16 csum_fold(__wsum sum)
  76 {
  77         asm volatile (
  78         "       lsr.4   d15, %0, #16    \n\t"
  79         "       bfextu  %0, %0, #16     \n\t"
  80         "       add.4   %0, d15, %0     \n\t"
  81         "       lsr.4   d15, %0, #16    \n\t"
  82         "       bfextu  %0, %0, #16     \n\t"
  83         "       add.4   %0, d15, %0     \n\t"
  84                 : "=&d" (sum)
  85                 : "0"(sum)
  86                 : "d15"
  87         );
  88         return (__force __sum16)~sum;
  89 }
  90
  91
  92 /*
  93  * computes the checksum of the TCP/UDP pseudo-header
  94  * returns a 16-bit checksum, already complemented
  95  */
  96
  97 static inline __wsum
  98 csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len,
  99                   unsigned short proto, __wsum sum)
 100 {
 101         asm volatile (
 102         "       add.4   %0, %2, %0      \n\t"
 103         "       addc    %0, %3, %0      \n\t"
 104         "       addc    %0, %4, %0      \n\t"
 105         "       addc    %0, %5, %0      \n\t"
 106         "       addc    %0, #0, %0      \n\t"
 107                 : "=&d" (sum)
 108                 : "0"(sum), "r" (saddr), "r" (daddr), "r" (len), "r"(proto)
 109         );
 110         return sum;
 111 }
 112
 113 static inline __sum16
 114 csum_tcpudp_magic(__be32 saddr, __be32 daddr, unsigned short len,
 115                   unsigned short proto, __wsum sum)
 116 {
 117         return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
 118 }
 119
 120 /*
 121  * this routine is used for miscellaneous IP-like checksums, mainly
 122  * in icmp.c
 123  */
 124 extern __sum16 ip_compute_csum(const void *buff, int len);
 125
 126 #define _HAVE_ARCH_IPV6_CSUM
 127
 128 static __inline__ __sum16
 129 csum_ipv6_magic(const struct in6_addr *saddr, const struct in6_addr *daddr,
 130                 __u32 len, unsigned short proto, __wsum sum)
 131 {
 132         asm volatile (
 133         "       add.4   %0, 0(%2), %0   \n\t"
 134         "       addc    %0, 4(%2), %0   \n\t"
 135         "       addc    %0, 8(%2), %0   \n\t"
 136         "       addc    %0, 12(%2), %0  \n\t"
 137         "       addc    %0, 0(%3), %0   \n\t"
 138         "       addc    %0, 4(%3), %0   \n\t"
 139         "       addc    %0, 8(%3), %0   \n\t"
 140         "       addc    %0, 12(%3), %0  \n\t"
 141         "       addc    %0, %4, %0      \n\t"
 142         "       addc    %0, #0, %0      \n\t"
 143                 : "=&d" (sum)
 144                 : "0" (sum), "a" (saddr), "a" (daddr), "d" (len + proto)
 145         );
 146         return csum_fold(sum);
 147 }
 148
 149 #endif /* _ASM_UBICOM32_CHECKSUM_H */