URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-mips/] [checksum.h] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * 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.
 *
 * Copyright (C) 1995, 1996, 1997, 1998, 2001 by Ralf Baechle
 */
#ifndef _ASM_CHECKSUM_H
#define _ASM_CHECKSUM_H
 
#include <asm/uaccess.h>
 
/*
 * computes the checksum of a memory block at buff, length len,
 * and adds in "sum" (32-bit)
 *
 * returns a 32-bit number suitable for feeding into itself
 * or csum_tcpudp_magic
 *
 * this function must be called with even lengths, except
 * for the last fragment, which may be odd
 *
 * it's best to have buff aligned on a 32-bit boundary
 */
unsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum);
 
/*
 * this is a new version of the above that records errors it finds in *errp,
 * but continues and zeros the rest of the buffer.
 */
#define csum_partial_copy_nocheck csum_partial_copy
 
/*
 * this is a new version of the above that records errors it finds in *errp,
 * but continues and zeros the rest of the buffer.
 */
unsigned int csum_partial_copy_from_user(const char *src, char *dst, int len,
                                         unsigned int sum, int *errp);
 
/*
 * Copy and checksum to user
 */
#define HAVE_CSUM_COPY_USER
static inline unsigned int csum_and_copy_to_user (const char *src, char *dst,
                                                  int len, int sum,
                                                  int *err_ptr)
{
        sum = csum_partial(src, len, sum);
 
        if (copy_to_user(dst, src, len)) {
                *err_ptr = -EFAULT;
                return -1;
        }
 
        return sum;
}
 
/*
 * the same as csum_partial, but copies from user space (but on MIPS
 * we have just one address space, so this is identical to the above)
 *
 * this is obsolete and will go away.
 */
#define csum_partial_copy_fromuser csum_partial_copy
unsigned int csum_partial_copy(const char *src, char *dst, int len,
                               unsigned int sum);
 
/*
 *      Fold a partial checksum without adding pseudo headers
 */
static inline unsigned short int csum_fold(unsigned int sum)
{
        __asm__(
        ".set\tnoat\t\t\t# csum_fold\n\t"
        "sll\t$1,%0,16\n\t"
        "addu\t%0,$1\n\t"
        "sltu\t$1,%0,$1\n\t"
        "srl\t%0,%0,16\n\t"
        "addu\t%0,$1\n\t"
        "xori\t%0,0xffff\n\t"
        ".set\tat"
        : "=r" (sum)
        : "0" (sum));
 
        return sum;
}
 
/*
 *      This is a version of ip_compute_csum() optimized for IP headers,
 *      which always checksum on 4 octet boundaries.
 *
 *      By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
 *      Arnt Gulbrandsen.
 */
static inline unsigned short ip_fast_csum(unsigned char *iph, unsigned int ihl)
{
        unsigned int *word = (unsigned int *) iph;
        unsigned int *stop = word + ihl;
        unsigned int csum;
        int carry;
 
        csum = word[0];
        csum += word[1];
        carry = (csum < word[1]);
        csum += carry;
 
        csum += word[2];
        carry = (csum < word[2]);
        csum += carry;
 
        csum += word[3];
        carry = (csum < word[3]);
        csum += carry;
 
        word += 4;
        do {
                csum += *word;
                carry = (csum < *word);
                csum += carry;
                word++;
        } while (word != stop);
 
        return csum_fold(csum);
}
 
/*
 * computes the checksum of the TCP/UDP pseudo-header
 * returns a 16-bit checksum, already complemented
 */
static inline unsigned long csum_tcpudp_nofold(unsigned long saddr,
                                               unsigned long daddr,
                                               unsigned short len,
                                               unsigned short proto,
                                               unsigned int sum)
{
        __asm__(
        ".set\tnoat\t\t\t# csum_tcpudp_nofold\n\t"
        "addu\t%0, %2\n\t"
        "sltu\t$1, %0, %2\n\t"
        "addu\t%0, $1\n\t"
 
        "addu\t%0, %3\n\t"
        "sltu\t$1, %0, %3\n\t"
        "addu\t%0, $1\n\t"
 
        "addu\t%0, %4\n\t"
        "sltu\t$1, %0, %4\n\t"
        "addu\t%0, $1\n\t"
        ".set\tat"
        : "=r" (sum)
        : "0" (daddr), "r"(saddr),
#ifdef __MIPSEL__
          "r" ((ntohs(len)<<16)+proto*256),
#else
          "r" (((proto)<<16)+len),
#endif
          "r" (sum));
 
        return sum;
}
 
/*
 * computes the checksum of the TCP/UDP pseudo-header
 * returns a 16-bit checksum, already complemented
 */
static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
                                                   unsigned long daddr,
                                                   unsigned short len,
                                                   unsigned short proto,
                                                   unsigned int sum)
{
        return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
}
 
/*
 * this routine is used for miscellaneous IP-like checksums, mainly
 * in icmp.c
 */
static inline unsigned short ip_compute_csum(unsigned char * buff, int len)
{
        return csum_fold(csum_partial(buff, len, 0));
}
 
#define _HAVE_ARCH_IPV6_CSUM
static __inline__ unsigned short int csum_ipv6_magic(struct in6_addr *saddr,
                                                     struct in6_addr *daddr,
                                                     __u32 len,
                                                     unsigned short proto,
                                                     unsigned int sum)
{
        __asm__(
        ".set\tpush\t\t\t# csum_ipv6_magic\n\t"
        ".set\tnoreorder\n\t"
        ".set\tnoat\n\t"
        "addu\t%0, %5\t\t\t# proto (long in network byte order)\n\t"
        "sltu\t$1, %0, %5\n\t"
        "addu\t%0, $1\n\t"
 
        "addu\t%0, %6\t\t\t# csum\n\t"
        "sltu\t$1, %0, %6\n\t"
        "lw\t%1, 0(%2)\t\t\t# four words source address\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 4(%2)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 8(%2)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 12(%2)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 0(%3)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 4(%3)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 8(%3)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "lw\t%1, 12(%3)\n\t"
        "addu\t%0, $1\n\t"
        "addu\t%0, %1\n\t"
        "sltu\t$1, %0, %1\n\t"
 
        "addu\t%0, $1\t\t\t# Add final carry\n\t"
        ".set\tpop"
        : "=r" (sum), "=r" (proto)
        : "r" (saddr), "r" (daddr),
          "0" (htonl(len)), "1" (htonl(proto)), "r" (sum));
 
        return csum_fold(sum);
}
 
#endif /* _ASM_CHECKSUM_H */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-mips/] [checksum.h] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1276	phoenix	`/*`
2			`* This file is subject to the terms and conditions of the GNU General Public`
3			`* License. See the file "COPYING" in the main directory of this archive`
4			`* for more details.`
5			`*`
6			`* Copyright (C) 1995, 1996, 1997, 1998, 2001 by Ralf Baechle`
7			`*/`
8			`#ifndef _ASM_CHECKSUM_H`
9			`#define _ASM_CHECKSUM_H`
10
11			`#include <asm/uaccess.h>`
12
13			`/*`
14			`* computes the checksum of a memory block at buff, length len,`
15			`* and adds in "sum" (32-bit)`
16			`*`
17			`* returns a 32-bit number suitable for feeding into itself`
18			`* or csum_tcpudp_magic`
19			`*`
20			`* this function must be called with even lengths, except`
21			`* for the last fragment, which may be odd`
22			`*`
23			`* it's best to have buff aligned on a 32-bit boundary`
24			`*/`
25			`unsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum);`
26
27			`/*`
28			`* this is a new version of the above that records errors it finds in *errp,`
29			`* but continues and zeros the rest of the buffer.`
30			`*/`
31			`#define csum_partial_copy_nocheck csum_partial_copy`
32
33			`/*`
34			`* this is a new version of the above that records errors it finds in *errp,`
35			`* but continues and zeros the rest of the buffer.`
36			`*/`
37			`unsigned int csum_partial_copy_from_user(const char src, char dst, int len,`
38			`unsigned int sum, int *errp);`
39
40			`/*`
41			`* Copy and checksum to user`
42			`*/`
43			`#define HAVE_CSUM_COPY_USER`
44			`static inline unsigned int csum_and_copy_to_user (const char src, char dst,`
45			`int len, int sum,`
46			`int *err_ptr)`
47			`{`
48			`sum = csum_partial(src, len, sum);`
49
50			`if (copy_to_user(dst, src, len)) {`
51			`*err_ptr = -EFAULT;`
52			`return -1;`
53			`}`
54
55			`return sum;`
56			`}`
57
58			`/*`
59			`* the same as csum_partial, but copies from user space (but on MIPS`
60			`* we have just one address space, so this is identical to the above)`
61			`*`
62			`* this is obsolete and will go away.`
63			`*/`
64			`#define csum_partial_copy_fromuser csum_partial_copy`
65			`unsigned int csum_partial_copy(const char src, char dst, int len,`
66			`unsigned int sum);`
67
68			`/*`
69			`* Fold a partial checksum without adding pseudo headers`
70			`*/`
71			`static inline unsigned short int csum_fold(unsigned int sum)`
72			`{`
73			`__asm__(`
74			`".set\tnoat\t\t\t# csum_fold\n\t"`
75			`"sll\t$1,%0,16\n\t"`
76			`"addu\t%0,$1\n\t"`
77			`"sltu\t$1,%0,$1\n\t"`
78			`"srl\t%0,%0,16\n\t"`
79			`"addu\t%0,$1\n\t"`
80			`"xori\t%0,0xffff\n\t"`
81			`".set\tat"`
82			`: "=r" (sum)`
83			`: "0" (sum));`
84
85			`return sum;`
86			`}`
87
88			`/*`
89			`* This is a version of ip_compute_csum() optimized for IP headers,`
90			`* which always checksum on 4 octet boundaries.`
91			`*`
92			`* By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by`
93			`* Arnt Gulbrandsen.`
94			`*/`
95			`static inline unsigned short ip_fast_csum(unsigned char *iph, unsigned int ihl)`
96			`{`
97			`unsigned int word = (unsigned int ) iph;`
98			`unsigned int *stop = word + ihl;`
99			`unsigned int csum;`
100			`int carry;`
101
102			`csum = word[0];`
103			`csum += word[1];`
104			`carry = (csum < word[1]);`
105			`csum += carry;`
106
107			`csum += word[2];`
108			`carry = (csum < word[2]);`
109			`csum += carry;`
110
111			`csum += word[3];`
112			`carry = (csum < word[3]);`
113			`csum += carry;`
114
115			`word += 4;`
116			`do {`
117			`csum += *word;`
118			`carry = (csum < *word);`
119			`csum += carry;`
120			`word++;`
121			`} while (word != stop);`
122
123			`return csum_fold(csum);`
124			`}`
125
126			`/*`
127			`* computes the checksum of the TCP/UDP pseudo-header`
128			`* returns a 16-bit checksum, already complemented`
129			`*/`
130			`static inline unsigned long csum_tcpudp_nofold(unsigned long saddr,`
131			`unsigned long daddr,`
132			`unsigned short len,`
133			`unsigned short proto,`
134			`unsigned int sum)`
135			`{`
136			`__asm__(`
137			`".set\tnoat\t\t\t# csum_tcpudp_nofold\n\t"`
138			`"addu\t%0, %2\n\t"`
139			`"sltu\t$1, %0, %2\n\t"`
140			`"addu\t%0, $1\n\t"`
141
142			`"addu\t%0, %3\n\t"`
143			`"sltu\t$1, %0, %3\n\t"`
144			`"addu\t%0, $1\n\t"`
145
146			`"addu\t%0, %4\n\t"`
147			`"sltu\t$1, %0, %4\n\t"`
148			`"addu\t%0, $1\n\t"`
149			`".set\tat"`
150			`: "=r" (sum)`
151			`: "0" (daddr), "r"(saddr),`
152			`#ifdef __MIPSEL__`
153			`"r" ((ntohs(len)<<16)+proto*256),`
154			`#else`
155			`"r" (((proto)<<16)+len),`
156			`#endif`
157			`"r" (sum));`
158
159			`return sum;`
160			`}`
161
162			`/*`
163			`* computes the checksum of the TCP/UDP pseudo-header`
164			`* returns a 16-bit checksum, already complemented`
165			`*/`
166			`static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,`
167			`unsigned long daddr,`
168			`unsigned short len,`
169			`unsigned short proto,`
170			`unsigned int sum)`
171			`{`
172			`return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));`
173			`}`
174
175			`/*`
176			`* this routine is used for miscellaneous IP-like checksums, mainly`
177			`* in icmp.c`
178			`*/`
179			`static inline unsigned short ip_compute_csum(unsigned char * buff, int len)`
180			`{`
181			`return csum_fold(csum_partial(buff, len, 0));`
182			`}`
183
184			`#define _HAVE_ARCH_IPV6_CSUM`
185			`static __inline__ unsigned short int csum_ipv6_magic(struct in6_addr *saddr,`
186			`struct in6_addr *daddr,`
187			`__u32 len,`
188			`unsigned short proto,`
189			`unsigned int sum)`
190			`{`
191			`__asm__(`
192			`".set\tpush\t\t\t# csum_ipv6_magic\n\t"`
193			`".set\tnoreorder\n\t"`
194			`".set\tnoat\n\t"`
195			`"addu\t%0, %5\t\t\t# proto (long in network byte order)\n\t"`
196			`"sltu\t$1, %0, %5\n\t"`
197			`"addu\t%0, $1\n\t"`
198
199			`"addu\t%0, %6\t\t\t# csum\n\t"`
200			`"sltu\t$1, %0, %6\n\t"`
201			`"lw\t%1, 0(%2)\t\t\t# four words source address\n\t"`
202			`"addu\t%0, $1\n\t"`
203			`"addu\t%0, %1\n\t"`
204			`"sltu\t$1, %0, %1\n\t"`
205
206			`"lw\t%1, 4(%2)\n\t"`
207			`"addu\t%0, $1\n\t"`
208			`"addu\t%0, %1\n\t"`
209			`"sltu\t$1, %0, %1\n\t"`
210
211			`"lw\t%1, 8(%2)\n\t"`
212			`"addu\t%0, $1\n\t"`
213			`"addu\t%0, %1\n\t"`
214			`"sltu\t$1, %0, %1\n\t"`
215
216			`"lw\t%1, 12(%2)\n\t"`
217			`"addu\t%0, $1\n\t"`
218			`"addu\t%0, %1\n\t"`
219			`"sltu\t$1, %0, %1\n\t"`
220
221			`"lw\t%1, 0(%3)\n\t"`
222			`"addu\t%0, $1\n\t"`
223			`"addu\t%0, %1\n\t"`
224			`"sltu\t$1, %0, %1\n\t"`
225
226			`"lw\t%1, 4(%3)\n\t"`
227			`"addu\t%0, $1\n\t"`
228			`"addu\t%0, %1\n\t"`
229			`"sltu\t$1, %0, %1\n\t"`
230
231			`"lw\t%1, 8(%3)\n\t"`
232			`"addu\t%0, $1\n\t"`
233			`"addu\t%0, %1\n\t"`
234			`"sltu\t$1, %0, %1\n\t"`
235
236			`"lw\t%1, 12(%3)\n\t"`
237			`"addu\t%0, $1\n\t"`
238			`"addu\t%0, %1\n\t"`
239			`"sltu\t$1, %0, %1\n\t"`
240
241			`"addu\t%0, $1\t\t\t# Add final carry\n\t"`
242			`".set\tpop"`
243			`: "=r" (sum), "=r" (proto)`
244			`: "r" (saddr), "r" (daddr),`
245			`"0" (htonl(len)), "1" (htonl(proto)), "r" (sum));`
246
247			`return csum_fold(sum);`
248			`}`
249
250			`#endif /* _ASM_CHECKSUM_H */`