arch/blackfin/lib/checksum.c

   1 /*
   2  * Copyright 2004-2009 Analog Devices Inc.
   3  *
   4  * Licensed under the GPL-2 or later.
   5  *
   6  * An implementation of the TCP/IP protocol suite for the LINUX operating
   7  * system. INET is implemented using the BSD Socket interface as the
   8  * means of communication with the user level.
   9  *
  10  */
  11
  12 #include <linux/module.h>
  13 #include <net/checksum.h>
  14 #include <asm/checksum.h>
  15
  16 #ifdef CONFIG_IP_CHECKSUM_L1
  17 static unsigned short do_csum(const unsigned char *buff, int len)__attribute__((l1_text));
  18 #endif
  19
  20 static unsigned short do_csum(const unsigned char *buff, int len)
  21 {
  22         register unsigned long sum = 0;
  23         int swappem = 0;
  24
  25         if (1 & (unsigned long)buff) {
  26                 sum = *buff << 8;
  27                 buff++;
  28                 len--;
  29                 ++swappem;
  30         }
  31
  32         while (len > 1) {
  33                 sum += *(unsigned short *)buff;
  34                 buff += 2;
  35                 len -= 2;
  36         }
  37
  38         if (len > 0)
  39                 sum += *buff;
  40
  41         /*  Fold 32-bit sum to 16 bits */
  42         while (sum >> 16)
  43                 sum = (sum & 0xffff) + (sum >> 16);
  44
  45         if (swappem)
  46                 sum = ((sum & 0xff00) >> 8) + ((sum & 0x00ff) << 8);
  47
  48         return sum;
  49
  50 }
  51
  52 /*
  53  *      This is a version of ip_compute_csum() optimized for IP headers,
  54  *      which always checksum on 4 octet boundaries.
  55  */
  56 __sum16 ip_fast_csum(unsigned char *iph, unsigned int ihl)
  57 {
  58         return (__force __sum16)~do_csum(iph, ihl * 4);
  59 }
  60 EXPORT_SYMBOL(ip_fast_csum);
  61
  62 /*
  63  * computes the checksum of a memory block at buff, length len,
  64  * and adds in "sum" (32-bit)
  65  *
  66  * returns a 32-bit number suitable for feeding into itself
  67  * or csum_tcpudp_magic
  68  *
  69  * this function must be called with even lengths, except
  70  * for the last fragment, which may be odd
  71  *
  72  * it's best to have buff aligned on a 32-bit boundary
  73  */
  74 __wsum csum_partial(const void *buff, int len, __wsum sum)
  75 {
  76         /*
  77          * Just in case we get nasty checksum data...
  78          * Like 0xffff6ec3 in the case of our IPv6 multicast header.
  79          * We fold to begin with, as well as at the end.
  80          */
  81         sum = (sum & 0xffff) + (sum >> 16);
  82
  83         sum += do_csum(buff, len);
  84
  85         sum = (sum & 0xffff) + (sum >> 16);
  86
  87         return sum;
  88 }
  89 EXPORT_SYMBOL(csum_partial);
  90
  91 /*
  92  * this routine is used for miscellaneous IP-like checksums, mainly
  93  * in icmp.c
  94  */
  95 __sum16 ip_compute_csum(const void *buff, int len)
  96 {
  97         return (__force __sum16)~do_csum(buff, len);
  98 }
  99 EXPORT_SYMBOL(ip_compute_csum);
 100
 101 /*
 102  * copy from fs while checksumming, otherwise like csum_partial
 103  */
 104
 105 __wsum
 106 csum_partial_copy_from_user(const void __user *src, void *dst,
 107                             int len, __wsum sum, int *csum_err)
 108 {
 109         if (csum_err)
 110                 *csum_err = 0;
 111         memcpy(dst, (__force void *)src, len);
 112         return csum_partial(dst, len, sum);
 113 }
 114 EXPORT_SYMBOL(csum_partial_copy_from_user);
 115
 116 /*
 117  * copy from ds while checksumming, otherwise like csum_partial
 118  */
 119
 120 __wsum csum_partial_copy(const void *src, void *dst, int len, __wsum sum)
 121 {
 122         memcpy(dst, src, len);
 123         return csum_partial(dst, len, sum);
 124 }
 125 EXPORT_SYMBOL(csum_partial_copy);