| 1 |
/* SPDX-License-Identifier: GPL-2.0 */ |
| 2 |
#ifndef __ASM_SH_CHECKSUM_H |
| 3 |
#define __ASM_SH_CHECKSUM_H |
| 4 |
|
| 5 |
/* |
| 6 |
* Copyright (C) 1999 by Kaz Kojima & Niibe Yutaka |
| 7 |
*/ |
| 8 |
|
| 9 |
#include <linux/in6.h> |
| 10 |
#include <linux/uaccess.h> |
| 11 |
|
| 12 |
/* |
| 13 |
* computes the checksum of a memory block at buff, length len, |
| 14 |
* and adds in "sum" (32-bit) |
| 15 |
* |
| 16 |
* returns a 32-bit number suitable for feeding into itself |
| 17 |
* or csum_tcpudp_magic |
| 18 |
* |
| 19 |
* this function must be called with even lengths, except |
| 20 |
* for the last fragment, which may be odd |
| 21 |
* |
| 22 |
* it's best to have buff aligned on a 32-bit boundary |
| 23 |
*/ |
| 24 |
asmlinkage __wsum csum_partial(const void *buff, int len, __wsum sum); |
| 25 |
|
| 26 |
/* |
| 27 |
* the same as csum_partial, but copies from src while it |
| 28 |
* checksums, and handles user-space pointer exceptions correctly, when needed. |
| 29 |
* |
| 30 |
* here even more important to align src and dst on a 32-bit (or even |
| 31 |
* better 64-bit) boundary |
| 32 |
*/ |
| 33 |
|
| 34 |
asmlinkage __wsum csum_partial_copy_generic(const void *src, void *dst, int len); |
| 35 |
|
| 36 |
#define _HAVE_ARCH_CSUM_AND_COPY |
| 37 |
/* |
| 38 |
* Note: when you get a NULL pointer exception here this means someone |
| 39 |
* passed in an incorrect kernel address to one of these functions. |
| 40 |
* |
| 41 |
* If you use these functions directly please don't forget the |
| 42 |
* access_ok(). |
| 43 |
*/ |
| 44 |
static inline |
| 45 |
__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len) |
| 46 |
{ |
| 47 |
return csum_partial_copy_generic(src, dst, len); |
| 48 |
} |
| 49 |
|
| 50 |
#define _HAVE_ARCH_COPY_AND_CSUM_FROM_USER |
| 51 |
static inline |
| 52 |
__wsum csum_and_copy_from_user(const void __user *src, void *dst, int len) |
| 53 |
{ |
| 54 |
if (!access_ok(src, len)) |
| 55 |
return 0; |
| 56 |
return csum_partial_copy_generic((__force const void *)src, dst, len); |
| 57 |
} |
| 58 |
|
| 59 |
/* |
| 60 |
* Fold a partial checksum |
| 61 |
*/ |
| 62 |
|
| 63 |
static inline __sum16 csum_fold(__wsum sum) |
| 64 |
{ |
| 65 |
unsigned int __dummy; |
| 66 |
__asm__("swap.w %0, %1\n\t" |
| 67 |
"extu.w %0, %0\n\t" |
| 68 |
"extu.w %1, %1\n\t" |
| 69 |
"add %1, %0\n\t" |
| 70 |
"swap.w %0, %1\n\t" |
| 71 |
"add %1, %0\n\t" |
| 72 |
"not %0, %0\n\t" |
| 73 |
: "=r" (sum), "=&r" (__dummy) |
| 74 |
: "0" (sum) |
| 75 |
: "t"); |
| 76 |
return (__force __sum16)sum; |
| 77 |
} |
| 78 |
|
| 79 |
/* |
| 80 |
* This is a version of ip_compute_csum() optimized for IP headers, |
| 81 |
* which always checksum on 4 octet boundaries. |
| 82 |
* |
| 83 |
* i386 version by Jorge Cwik <[email protected]>, adapted |
| 84 |
* for linux by * Arnt Gulbrandsen. |
| 85 |
*/ |
| 86 |
static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl) |
| 87 |
{ |
| 88 |
__wsum sum; |
| 89 |
unsigned int __dummy0, __dummy1; |
| 90 |
|
| 91 |
__asm__ __volatile__( |
| 92 |
"mov.l @%1+, %0\n\t" |
| 93 |
"mov.l @%1+, %3\n\t" |
| 94 |
"add #-2, %2\n\t" |
| 95 |
"clrt\n\t" |
| 96 |
"1:\t" |
| 97 |
"addc %3, %0\n\t" |
| 98 |
"movt %4\n\t" |
| 99 |
"mov.l @%1+, %3\n\t" |
| 100 |
"dt %2\n\t" |
| 101 |
"bf/s 1b\n\t" |
| 102 |
" cmp/eq #1, %4\n\t" |
| 103 |
"addc %3, %0\n\t" |
| 104 |
"addc %2, %0" /* Here %2 is 0, add carry-bit */ |
| 105 |
/* Since the input registers which are loaded with iph and ihl |
| 106 |
are modified, we must also specify them as outputs, or gcc |
| 107 |
will assume they contain their original values. */ |
| 108 |
: "=r" (sum), "=r" (iph), "=r" (ihl), "=&r" (__dummy0), "=&z" (__dummy1) |
| 109 |
: "1" (iph), "2" (ihl) |
| 110 |
: "t", "memory"); |
| 111 |
|
| 112 |
return csum_fold(sum); |
| 113 |
} |
| 114 |
|
| 115 |
static inline __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr, |
| 116 |
__u32 len, __u8 proto, |
| 117 |
__wsum sum) |
| 118 |
{ |
| 119 |
#ifdef __LITTLE_ENDIAN__ |
| 120 |
unsigned long len_proto = (proto + len) << 8; |
| 121 |
#else |
| 122 |
unsigned long len_proto = proto + len; |
| 123 |
#endif |
| 124 |
__asm__("clrt\n\t" |
| 125 |
"addc %0, %1\n\t" |
| 126 |
"addc %2, %1\n\t" |
| 127 |
"addc %3, %1\n\t" |
| 128 |
"movt %0\n\t" |
| 129 |
"add %1, %0" |
| 130 |
: "=r" (sum), "=r" (len_proto) |
| 131 |
: "r" (daddr), "r" (saddr), "1" (len_proto), "0" (sum) |
| 132 |
: "t"); |
| 133 |
|
| 134 |
return sum; |
| 135 |
} |
| 136 |
|
| 137 |
/* |
| 138 |
* computes the checksum of the TCP/UDP pseudo-header |
| 139 |
* returns a 16-bit checksum, already complemented |
| 140 |
*/ |
| 141 |
static inline __sum16 csum_tcpudp_magic(__be32 saddr, __be32 daddr, |
| 142 |
__u32 len, __u8 proto, |
| 143 |
__wsum sum) |
| 144 |
{ |
| 145 |
return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum)); |
| 146 |
} |
| 147 |
|
| 148 |
/* |
| 149 |
* this routine is used for miscellaneous IP-like checksums, mainly |
| 150 |
* in icmp.c |
| 151 |
*/ |
| 152 |
static inline __sum16 ip_compute_csum(const void *buff, int len) |
| 153 |
{ |
| 154 |
return csum_fold(csum_partial(buff, len, 0)); |
| 155 |
} |
| 156 |
|
| 157 |
#define _HAVE_ARCH_IPV6_CSUM |
| 158 |
static inline __sum16 csum_ipv6_magic(const struct in6_addr *saddr, |
| 159 |
const struct in6_addr *daddr, |
| 160 |
__u32 len, __u8 proto, __wsum sum) |
| 161 |
{ |
| 162 |
unsigned int __dummy; |
| 163 |
__asm__("clrt\n\t" |
| 164 |
"mov.l @(0,%2), %1\n\t" |
| 165 |
"addc %1, %0\n\t" |
| 166 |
"mov.l @(4,%2), %1\n\t" |
| 167 |
"addc %1, %0\n\t" |
| 168 |
"mov.l @(8,%2), %1\n\t" |
| 169 |
"addc %1, %0\n\t" |
| 170 |
"mov.l @(12,%2), %1\n\t" |
| 171 |
"addc %1, %0\n\t" |
| 172 |
"mov.l @(0,%3), %1\n\t" |
| 173 |
"addc %1, %0\n\t" |
| 174 |
"mov.l @(4,%3), %1\n\t" |
| 175 |
"addc %1, %0\n\t" |
| 176 |
"mov.l @(8,%3), %1\n\t" |
| 177 |
"addc %1, %0\n\t" |
| 178 |
"mov.l @(12,%3), %1\n\t" |
| 179 |
"addc %1, %0\n\t" |
| 180 |
"addc %4, %0\n\t" |
| 181 |
"addc %5, %0\n\t" |
| 182 |
"movt %1\n\t" |
| 183 |
"add %1, %0\n" |
| 184 |
: "=r" (sum), "=&r" (__dummy) |
| 185 |
: "r" (saddr), "r" (daddr), |
| 186 |
"r" (htonl(len)), "r" (htonl(proto)), "0" (sum) |
| 187 |
: "t"); |
| 188 |
|
| 189 |
return csum_fold(sum); |
| 190 |
} |
| 191 |
|
| 192 |
/* |
| 193 |
* Copy and checksum to user |
| 194 |
*/ |
| 195 |
#define HAVE_CSUM_COPY_USER |
| 196 |
static inline __wsum csum_and_copy_to_user(const void *src, |
| 197 |
void __user *dst, |
| 198 |
int len) |
| 199 |
{ |
| 200 |
if (!access_ok(dst, len)) |
| 201 |
return 0; |
| 202 |
return csum_partial_copy_generic(src, (__force void *)dst, len); |
| 203 |
} |
| 204 |
#endif /* __ASM_SH_CHECKSUM_H */ |