Blackfin arch: as pointed out by Robert P. J. Day, update the CPU_FREQ name to match...
[linux-2.6.git] / arch / blackfin / lib / divsi3.S
1 /*
2  * File:         arch/blackfin/lib/divsi3.S
3  * Based on:
4  * Author:
5  *
6  * Created:
7  * Description:  16 / 32 bit signed division.
8  *                 Special cases :
9  *                      1)  If(numerator == 0)
10  *                             return 0
11  *                      2)  If(denominator ==0)
12  *                             return positive max = 0x7fffffff
13  *                      3)  If(numerator == denominator)
14  *                             return 1
15  *                      4)  If(denominator ==1)
16  *                             return numerator
17  *                      5)  If(denominator == -1)
18  *                             return -numerator
19  *
20  *                 Operand         : R0 - Numerator   (i)
21  *                                   R1 - Denominator (i)
22  *                                   R0 - Quotient    (o)
23  *                 Registers Used : R2-R7,P0-P2
24  *
25  * Modified:
26  *               Copyright 2004-2006 Analog Devices Inc.
27  *
28  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
29  *
30  * This program is free software; you can redistribute it and/or modify
31  * it under the terms of the GNU General Public License as published by
32  * the Free Software Foundation; either version 2 of the License, or
33  * (at your option) any later version.
34  *
35  * This program is distributed in the hope that it will be useful,
36  * but WITHOUT ANY WARRANTY; without even the implied warranty of
37  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
38  * GNU General Public License for more details.
39  *
40  * You should have received a copy of the GNU General Public License
41  * along with this program; if not, see the file COPYING, or write
42  * to the Free Software Foundation, Inc.,
43  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
44  */
45
46 .global   ___divsi3;
47 .type ___divsi3, STT_FUNC;
48
49 #ifdef CONFIG_ARITHMETIC_OPS_L1
50 .section .l1.text
51 #else
52 .text
53 #endif
54
55 .align 2;
56 ___divsi3 :
57
58
59   R3 = R0 ^ R1;
60   R0 = ABS R0;
61
62   CC = V;
63
64   r3 = rot r3 by -1;
65   r1 = abs r1;      /* now both positive, r3.30 means "negate result",
66                     ** r3.31 means overflow, add one to result
67                     */
68   cc = r0 < r1;
69   if cc jump .Lret_zero;
70   r2 = r1 >> 15;
71   cc = r2;
72   if cc jump .Lidents;
73   r2 = r1 << 16;
74   cc = r2 <= r0;
75   if cc jump .Lidents;
76
77   DIVS(R0, R1);
78   DIVQ(R0, R1);
79   DIVQ(R0, R1);
80   DIVQ(R0, R1);
81   DIVQ(R0, R1);
82   DIVQ(R0, R1);
83   DIVQ(R0, R1);
84   DIVQ(R0, R1);
85   DIVQ(R0, R1);
86   DIVQ(R0, R1);
87   DIVQ(R0, R1);
88   DIVQ(R0, R1);
89   DIVQ(R0, R1);
90   DIVQ(R0, R1);
91   DIVQ(R0, R1);
92   DIVQ(R0, R1);
93   DIVQ(R0, R1);
94
95   R0 = R0.L (Z);
96   r1 = r3 >> 31;    /* add overflow issue back in */
97   r0 = r0 + r1;
98   r1 = -r0;
99   cc = bittst(r3, 30);
100   if cc r0 = r1;
101   RTS;
102
103 /* Can't use the primitives. Test common identities.
104 ** If the identity is true, return the value in R2.
105 */
106
107 .Lidents:
108   CC = R1 == 0;                   /* check for divide by zero */
109   IF CC JUMP .Lident_return;
110
111   CC = R0 == 0;                   /* check for division of zero */
112   IF CC JUMP .Lzero_return;
113
114   CC = R0 == R1;                  /* check for identical operands */
115   IF CC JUMP .Lident_return;
116
117   CC = R1 == 1;                   /* check for divide by 1 */
118   IF CC JUMP .Lident_return;
119
120   R2.L = ONES R1;
121   R2 = R2.L (Z);
122   CC = R2 == 1;
123   IF CC JUMP .Lpower_of_two;
124
125   /* Identities haven't helped either.
126   ** Perform the full division process.
127   */
128
129   P1 = 31;                        /* Set loop counter   */
130
131   [--SP] = (R7:5);                /* Push registers R5-R7 */
132   R2 = -R1;
133   [--SP] = R2;
134   R2 = R0 << 1;                   /* R2 lsw of dividend  */
135   R6 = R0 ^ R1;                   /* Get sign */
136   R5 = R6 >> 31;                  /* Shift sign to LSB */
137
138   R0 = 0 ;                        /* Clear msw partial remainder */
139   R2 = R2 | R5;                   /* Shift quotient bit */
140   R6 = R0 ^ R1;                   /* Get new quotient bit */
141
142   LSETUP(.Llst,.Llend)  LC0 = P1;   /* Setup loop */
143 .Llst:   R7 = R2 >> 31;            /* record copy of carry from R2 */
144         R2 = R2 << 1;             /* Shift 64 bit dividend up by 1 bit */
145         R0 = R0 << 1 || R5 = [SP];
146         R0 = R0 | R7;             /* and add carry */
147         CC = R6 < 0;              /* Check quotient(AQ) */
148                                   /* we might be subtracting divisor (AQ==0) */
149         IF CC R5 = R1;            /* or we might be adding divisor  (AQ==1)*/
150         R0 = R0 + R5;             /* do add or subtract, as indicated by AQ */
151         R6 = R0 ^ R1;             /* Generate next quotient bit */
152         R5 = R6 >> 31;
153                                   /* Assume AQ==1, shift in zero */
154         BITTGL(R5,0);             /* tweak AQ to be what we want to shift in */
155 .Llend:  R2 = R2 + R5;             /* and then set shifted-in value to
156                                   ** tweaked AQ.
157                                   */
158   r1 = r3 >> 31;
159   r2 = r2 + r1;
160   cc = bittst(r3,30);
161   r0 = -r2;
162   if !cc r0 = r2;
163   SP += 4;
164   (R7:5)= [SP++];                 /* Pop registers R6-R7 */
165   RTS;
166
167 .Lident_return:
168   CC = R1 == 0;                   /* check for divide by zero  => 0x7fffffff */
169   R2 = -1 (X);
170   R2 >>= 1;
171   IF CC JUMP .Ltrue_ident_return;
172
173   CC = R0 == R1;                  /* check for identical operands => 1 */
174   R2 = 1 (Z);
175   IF CC JUMP .Ltrue_ident_return;
176
177   R2 = R0;                        /* assume divide by 1 => numerator */
178   /*FALLTHRU*/
179
180 .Ltrue_ident_return:
181   R0 = R2;                        /* Return an identity value */
182   R2 = -R2;
183   CC = bittst(R3,30);
184   IF CC R0 = R2;
185 .Lzero_return:
186   RTS;                            /* ...including zero */
187
188 .Lpower_of_two:
189   /* Y has a single bit set, which means it's a power of two.
190   ** That means we can perform the division just by shifting
191   ** X to the right the appropriate number of bits
192   */
193
194   /* signbits returns the number of sign bits, minus one.
195   ** 1=>30, 2=>29, ..., 0x40000000=>0. Which means we need
196   ** to shift right n-signbits spaces. It also means 0x80000000
197   ** is a special case, because that *also* gives a signbits of 0
198   */
199
200   R2 = R0 >> 31;
201   CC = R1 < 0;
202   IF CC JUMP .Ltrue_ident_return;
203
204   R1.l = SIGNBITS R1;
205   R1 = R1.L (Z);
206   R1 += -30;
207   R0 = LSHIFT R0 by R1.L;
208   r1 = r3 >> 31;
209   r0 = r0 + r1;
210   R2 = -R0;                       // negate result if necessary
211   CC = bittst(R3,30);
212   IF CC R0 = R2;
213   RTS;
214
215 .Lret_zero:
216   R0 = 0;
217   RTS;
218
219 .size ___divsi3, .-___divsi3