aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/isdn/hisax/netjet.c
diff options
context:
space:
mode:
authorJoe Perches <joe@perches.com>2012-02-19 22:52:38 -0500
committerJoe Perches <joe@perches.com>2012-02-21 12:04:01 -0500
commit475be4d85a274d0961593db41cf85689db1d583c (patch)
treeb2b8931eb747794730522c3cf1898e46948527b9 /drivers/isdn/hisax/netjet.c
parent0b0a635f79f91f3755b6518627ea06dd0dbfd523 (diff)
isdn: whitespace coding style cleanup
isdn source code uses a not-current coding style. Update the coding style used on a per-line basis so that git diff -w shows only elided blank lines at EOF. Done with emacs and some scripts and some typing. Built x86 allyesconfig. No detected change in objdump -d or size. Signed-off-by: Joe Perches <joe@perches.com>
Diffstat (limited to 'drivers/isdn/hisax/netjet.c')
-rw-r--r--drivers/isdn/hisax/netjet.c623
1 files changed, 311 insertions, 312 deletions
diff --git a/drivers/isdn/hisax/netjet.c b/drivers/isdn/hisax/netjet.c
index 644891efc26f..b646eed379df 100644
--- a/drivers/isdn/hisax/netjet.c
+++ b/drivers/isdn/hisax/netjet.c
@@ -4,7 +4,7 @@
4 * 4 *
5 * Author Karsten Keil 5 * Author Karsten Keil
6 * Copyright by Karsten Keil <keil@isdn4linux.de> 6 * Copyright by Karsten Keil <keil@isdn4linux.de>
7 * 7 *
8 * This software may be used and distributed according to the terms 8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference. 9 * of the GNU General Public License, incorporated herein by reference.
10 * 10 *
@@ -31,21 +31,21 @@ u_char
31NETjet_ReadIC(struct IsdnCardState *cs, u_char offset) 31NETjet_ReadIC(struct IsdnCardState *cs, u_char offset)
32{ 32{
33 u_char ret; 33 u_char ret;
34 34
35 cs->hw.njet.auxd &= 0xfc; 35 cs->hw.njet.auxd &= 0xfc;
36 cs->hw.njet.auxd |= (offset>>4) & 3; 36 cs->hw.njet.auxd |= (offset >> 4) & 3;
37 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd); 37 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
38 ret = bytein(cs->hw.njet.isac + ((offset & 0xf)<<2)); 38 ret = bytein(cs->hw.njet.isac + ((offset & 0xf) << 2));
39 return(ret); 39 return (ret);
40} 40}
41 41
42void 42void
43NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value) 43NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value)
44{ 44{
45 cs->hw.njet.auxd &= 0xfc; 45 cs->hw.njet.auxd &= 0xfc;
46 cs->hw.njet.auxd |= (offset>>4) & 3; 46 cs->hw.njet.auxd |= (offset >> 4) & 3;
47 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd); 47 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
48 byteout(cs->hw.njet.isac + ((offset & 0xf)<<2), value); 48 byteout(cs->hw.njet.isac + ((offset & 0xf) << 2), value);
49} 49}
50 50
51void 51void
@@ -56,7 +56,7 @@ NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size)
56 insb(cs->hw.njet.isac, data, size); 56 insb(cs->hw.njet.isac, data, size);
57} 57}
58 58
59void 59void
60NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size) 60NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
61{ 61{
62 cs->hw.njet.auxd &= 0xfc; 62 cs->hw.njet.auxd &= 0xfc;
@@ -66,17 +66,17 @@ NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
66 66
67static void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill) 67static void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill)
68{ 68{
69 u_int mask=0x000000ff, val = 0, *p=pos; 69 u_int mask = 0x000000ff, val = 0, *p = pos;
70 u_int i; 70 u_int i;
71 71
72 val |= fill; 72 val |= fill;
73 if (chan) { 73 if (chan) {
74 val <<= 8; 74 val <<= 8;
75 mask <<= 8; 75 mask <<= 8;
76 } 76 }
77 mask ^= 0xffffffff; 77 mask ^= 0xffffffff;
78 for (i=0; i<cnt; i++) { 78 for (i = 0; i < cnt; i++) {
79 *p &= mask; 79 *p &= mask;
80 *p++ |= val; 80 *p++ |= val;
81 if (p > bcs->hw.tiger.s_end) 81 if (p > bcs->hw.tiger.s_end)
82 p = bcs->hw.tiger.send; 82 p = bcs->hw.tiger.send;
@@ -87,7 +87,7 @@ static void
87mode_tiger(struct BCState *bcs, int mode, int bc) 87mode_tiger(struct BCState *bcs, int mode, int bc)
88{ 88{
89 struct IsdnCardState *cs = bcs->cs; 89 struct IsdnCardState *cs = bcs->cs;
90 u_char led; 90 u_char led;
91 91
92 if (cs->debug & L1_DEB_HSCX) 92 if (cs->debug & L1_DEB_HSCX)
93 debugl1(cs, "Tiger mode %d bchan %d/%d", 93 debugl1(cs, "Tiger mode %d bchan %d/%d",
@@ -95,63 +95,63 @@ mode_tiger(struct BCState *bcs, int mode, int bc)
95 bcs->mode = mode; 95 bcs->mode = mode;
96 bcs->channel = bc; 96 bcs->channel = bc;
97 switch (mode) { 97 switch (mode) {
98 case (L1_MODE_NULL): 98 case (L1_MODE_NULL):
99 fill_mem(bcs, bcs->hw.tiger.send, 99 fill_mem(bcs, bcs->hw.tiger.send,
100 NETJET_DMA_TXSIZE, bc, 0xff); 100 NETJET_DMA_TXSIZE, bc, 0xff);
101 if (cs->debug & L1_DEB_HSCX) 101 if (cs->debug & L1_DEB_HSCX)
102 debugl1(cs, "Tiger stat rec %d/%d send %d", 102 debugl1(cs, "Tiger stat rec %d/%d send %d",
103 bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err, 103 bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err,
104 bcs->hw.tiger.s_tot); 104 bcs->hw.tiger.s_tot);
105 if ((cs->bcs[0].mode == L1_MODE_NULL) && 105 if ((cs->bcs[0].mode == L1_MODE_NULL) &&
106 (cs->bcs[1].mode == L1_MODE_NULL)) { 106 (cs->bcs[1].mode == L1_MODE_NULL)) {
107 cs->hw.njet.dmactrl = 0; 107 cs->hw.njet.dmactrl = 0;
108 byteout(cs->hw.njet.base + NETJET_DMACTRL, 108 byteout(cs->hw.njet.base + NETJET_DMACTRL,
109 cs->hw.njet.dmactrl); 109 cs->hw.njet.dmactrl);
110 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0); 110 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
111 } 111 }
112 if (cs->typ == ISDN_CTYPE_NETJET_S) 112 if (cs->typ == ISDN_CTYPE_NETJET_S)
113 { 113 {
114 // led off 114 // led off
115 led = bc & 0x01; 115 led = bc & 0x01;
116 led = 0x01 << (6 + led); // convert to mask 116 led = 0x01 << (6 + led); // convert to mask
117 led = ~led; 117 led = ~led;
118 cs->hw.njet.auxd &= led; 118 cs->hw.njet.auxd &= led;
119 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd); 119 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
120 } 120 }
121 break; 121 break;
122 case (L1_MODE_TRANS): 122 case (L1_MODE_TRANS):
123 break; 123 break;
124 case (L1_MODE_HDLC_56K): 124 case (L1_MODE_HDLC_56K):
125 case (L1_MODE_HDLC): 125 case (L1_MODE_HDLC):
126 fill_mem(bcs, bcs->hw.tiger.send,
127 NETJET_DMA_TXSIZE, bc, 0xff);
128 bcs->hw.tiger.r_state = HDLC_ZERO_SEARCH;
129 bcs->hw.tiger.r_tot = 0;
130 bcs->hw.tiger.r_bitcnt = 0;
131 bcs->hw.tiger.r_one = 0;
132 bcs->hw.tiger.r_err = 0;
133 bcs->hw.tiger.s_tot = 0;
134 if (!cs->hw.njet.dmactrl) {
126 fill_mem(bcs, bcs->hw.tiger.send, 135 fill_mem(bcs, bcs->hw.tiger.send,
127 NETJET_DMA_TXSIZE, bc, 0xff); 136 NETJET_DMA_TXSIZE, !bc, 0xff);
128 bcs->hw.tiger.r_state = HDLC_ZERO_SEARCH; 137 cs->hw.njet.dmactrl = 1;
129 bcs->hw.tiger.r_tot = 0; 138 byteout(cs->hw.njet.base + NETJET_DMACTRL,
130 bcs->hw.tiger.r_bitcnt = 0; 139 cs->hw.njet.dmactrl);
131 bcs->hw.tiger.r_one = 0; 140 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0x0f);
132 bcs->hw.tiger.r_err = 0;
133 bcs->hw.tiger.s_tot = 0;
134 if (! cs->hw.njet.dmactrl) {
135 fill_mem(bcs, bcs->hw.tiger.send,
136 NETJET_DMA_TXSIZE, !bc, 0xff);
137 cs->hw.njet.dmactrl = 1;
138 byteout(cs->hw.njet.base + NETJET_DMACTRL,
139 cs->hw.njet.dmactrl);
140 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0x0f);
141 /* was 0x3f now 0x0f for TJ300 and TJ320 GE 13/07/00 */ 141 /* was 0x3f now 0x0f for TJ300 and TJ320 GE 13/07/00 */
142 } 142 }
143 bcs->hw.tiger.sendp = bcs->hw.tiger.send; 143 bcs->hw.tiger.sendp = bcs->hw.tiger.send;
144 bcs->hw.tiger.free = NETJET_DMA_TXSIZE; 144 bcs->hw.tiger.free = NETJET_DMA_TXSIZE;
145 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag); 145 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
146 if (cs->typ == ISDN_CTYPE_NETJET_S) 146 if (cs->typ == ISDN_CTYPE_NETJET_S)
147 { 147 {
148 // led on 148 // led on
149 led = bc & 0x01; 149 led = bc & 0x01;
150 led = 0x01 << (6 + led); // convert to mask 150 led = 0x01 << (6 + led); // convert to mask
151 cs->hw.njet.auxd |= led; 151 cs->hw.njet.auxd |= led;
152 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd); 152 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
153 } 153 }
154 break; 154 break;
155 } 155 }
156 if (cs->debug & L1_DEB_HSCX) 156 if (cs->debug & L1_DEB_HSCX)
157 debugl1(cs, "tiger: set %x %x %x %x/%x pulse=%d", 157 debugl1(cs, "tiger: set %x %x %x %x/%x pulse=%d",
@@ -166,15 +166,15 @@ mode_tiger(struct BCState *bcs, int mode, int bc)
166static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s) { 166static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s) {
167 char tmp[128]; 167 char tmp[128];
168 char *t = tmp; 168 char *t = tmp;
169 int i=count,j; 169 int i = count, j;
170 u_char *p = buf; 170 u_char *p = buf;
171 171
172 t += sprintf(t, "tiger %s(%4d)", s, count); 172 t += sprintf(t, "tiger %s(%4d)", s, count);
173 while (i>0) { 173 while (i > 0) {
174 if (i>16) 174 if (i > 16)
175 j=16; 175 j = 16;
176 else 176 else
177 j=i; 177 j = i;
178 QuickHex(t, p, j); 178 QuickHex(t, p, j);
179 debugl1(cs, tmp); 179 debugl1(cs, tmp);
180 p += j; 180 p += j;
@@ -186,78 +186,78 @@ static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s
186 186
187// macro for 64k 187// macro for 64k
188 188
189#define MAKE_RAW_BYTE for (j=0; j<8; j++) { \ 189#define MAKE_RAW_BYTE for (j = 0; j < 8; j++) { \
190 bitcnt++;\ 190 bitcnt++; \
191 s_val >>= 1;\ 191 s_val >>= 1; \
192 if (val & 1) {\ 192 if (val & 1) { \
193 s_one++;\ 193 s_one++; \
194 s_val |= 0x80;\ 194 s_val |= 0x80; \
195 } else {\ 195 } else { \
196 s_one = 0;\ 196 s_one = 0; \
197 s_val &= 0x7f;\ 197 s_val &= 0x7f; \
198 }\ 198 } \
199 if (bitcnt==8) {\ 199 if (bitcnt == 8) { \
200 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\ 200 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
201 bitcnt = 0;\ 201 bitcnt = 0; \
202 }\ 202 } \
203 if (s_one == 5) {\ 203 if (s_one == 5) { \
204 s_val >>= 1;\ 204 s_val >>= 1; \
205 s_val &= 0x7f;\ 205 s_val &= 0x7f; \
206 bitcnt++;\ 206 bitcnt++; \
207 s_one = 0;\ 207 s_one = 0; \
208 }\ 208 } \
209 if (bitcnt==8) {\ 209 if (bitcnt == 8) { \
210 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\ 210 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
211 bitcnt = 0;\ 211 bitcnt = 0; \
212 }\ 212 } \
213 val >>= 1;\ 213 val >>= 1; \
214 } 214 }
215 215
216static int make_raw_data(struct BCState *bcs) { 216static int make_raw_data(struct BCState *bcs) {
217// this make_raw is for 64k 217// this make_raw is for 64k
218 register u_int i,s_cnt=0; 218 register u_int i, s_cnt = 0;
219 register u_char j; 219 register u_char j;
220 register u_char val; 220 register u_char val;
221 register u_char s_one = 0; 221 register u_char s_one = 0;
222 register u_char s_val = 0; 222 register u_char s_val = 0;
223 register u_char bitcnt = 0; 223 register u_char bitcnt = 0;
224 u_int fcs; 224 u_int fcs;
225 225
226 if (!bcs->tx_skb) { 226 if (!bcs->tx_skb) {
227 debugl1(bcs->cs, "tiger make_raw: NULL skb"); 227 debugl1(bcs->cs, "tiger make_raw: NULL skb");
228 return(1); 228 return (1);
229 } 229 }
230 bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE; 230 bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE;
231 fcs = PPP_INITFCS; 231 fcs = PPP_INITFCS;
232 for (i=0; i<bcs->tx_skb->len; i++) { 232 for (i = 0; i < bcs->tx_skb->len; i++) {
233 val = bcs->tx_skb->data[i]; 233 val = bcs->tx_skb->data[i];
234 fcs = PPP_FCS (fcs, val); 234 fcs = PPP_FCS(fcs, val);
235 MAKE_RAW_BYTE; 235 MAKE_RAW_BYTE;
236 } 236 }
237 fcs ^= 0xffff; 237 fcs ^= 0xffff;
238 val = fcs & 0xff; 238 val = fcs & 0xff;
239 MAKE_RAW_BYTE; 239 MAKE_RAW_BYTE;
240 val = (fcs>>8) & 0xff; 240 val = (fcs >> 8) & 0xff;
241 MAKE_RAW_BYTE; 241 MAKE_RAW_BYTE;
242 val = HDLC_FLAG_VALUE; 242 val = HDLC_FLAG_VALUE;
243 for (j=0; j<8; j++) { 243 for (j = 0; j < 8; j++) {
244 bitcnt++; 244 bitcnt++;
245 s_val >>= 1; 245 s_val >>= 1;
246 if (val & 1) 246 if (val & 1)
247 s_val |= 0x80; 247 s_val |= 0x80;
248 else 248 else
249 s_val &= 0x7f; 249 s_val &= 0x7f;
250 if (bitcnt==8) { 250 if (bitcnt == 8) {
251 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; 251 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
252 bitcnt = 0; 252 bitcnt = 0;
253 } 253 }
254 val >>= 1; 254 val >>= 1;
255 } 255 }
256 if (bcs->cs->debug & L1_DEB_HSCX) 256 if (bcs->cs->debug & L1_DEB_HSCX)
257 debugl1(bcs->cs,"tiger make_raw: in %u out %d.%d", 257 debugl1(bcs->cs, "tiger make_raw: in %u out %d.%d",
258 bcs->tx_skb->len, s_cnt, bitcnt); 258 bcs->tx_skb->len, s_cnt, bitcnt);
259 if (bitcnt) { 259 if (bitcnt) {
260 while (8>bitcnt++) { 260 while (8 > bitcnt++) {
261 s_val >>= 1; 261 s_val >>= 1;
262 s_val |= 0x80; 262 s_val |= 0x80;
263 } 263 }
@@ -267,65 +267,65 @@ static int make_raw_data(struct BCState *bcs) {
267 bcs->hw.tiger.sendcnt = s_cnt; 267 bcs->hw.tiger.sendcnt = s_cnt;
268 bcs->tx_cnt -= bcs->tx_skb->len; 268 bcs->tx_cnt -= bcs->tx_skb->len;
269 bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf; 269 bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
270 return(0); 270 return (0);
271} 271}
272 272
273// macro for 56k 273// macro for 56k
274 274
275#define MAKE_RAW_BYTE_56K for (j=0; j<8; j++) { \ 275#define MAKE_RAW_BYTE_56K for (j = 0; j < 8; j++) { \
276 bitcnt++;\ 276 bitcnt++; \
277 s_val >>= 1;\ 277 s_val >>= 1; \
278 if (val & 1) {\ 278 if (val & 1) { \
279 s_one++;\ 279 s_one++; \
280 s_val |= 0x80;\ 280 s_val |= 0x80; \
281 } else {\ 281 } else { \
282 s_one = 0;\ 282 s_one = 0; \
283 s_val &= 0x7f;\ 283 s_val &= 0x7f; \
284 }\ 284 } \
285 if (bitcnt==7) {\ 285 if (bitcnt == 7) { \
286 s_val >>= 1;\ 286 s_val >>= 1; \
287 s_val |= 0x80;\ 287 s_val |= 0x80; \
288 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\ 288 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
289 bitcnt = 0;\ 289 bitcnt = 0; \
290 }\ 290 } \
291 if (s_one == 5) {\ 291 if (s_one == 5) { \
292 s_val >>= 1;\ 292 s_val >>= 1; \
293 s_val &= 0x7f;\ 293 s_val &= 0x7f; \
294 bitcnt++;\ 294 bitcnt++; \
295 s_one = 0;\ 295 s_one = 0; \
296 }\ 296 } \
297 if (bitcnt==7) {\ 297 if (bitcnt == 7) { \
298 s_val >>= 1;\ 298 s_val >>= 1; \
299 s_val |= 0x80;\ 299 s_val |= 0x80; \
300 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\ 300 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
301 bitcnt = 0;\ 301 bitcnt = 0; \
302 }\ 302 } \
303 val >>= 1;\ 303 val >>= 1; \
304 } 304 }
305 305
306static int make_raw_data_56k(struct BCState *bcs) { 306static int make_raw_data_56k(struct BCState *bcs) {
307// this make_raw is for 56k 307// this make_raw is for 56k
308 register u_int i,s_cnt=0; 308 register u_int i, s_cnt = 0;
309 register u_char j; 309 register u_char j;
310 register u_char val; 310 register u_char val;
311 register u_char s_one = 0; 311 register u_char s_one = 0;
312 register u_char s_val = 0; 312 register u_char s_val = 0;
313 register u_char bitcnt = 0; 313 register u_char bitcnt = 0;
314 u_int fcs; 314 u_int fcs;
315 315
316 if (!bcs->tx_skb) { 316 if (!bcs->tx_skb) {
317 debugl1(bcs->cs, "tiger make_raw_56k: NULL skb"); 317 debugl1(bcs->cs, "tiger make_raw_56k: NULL skb");
318 return(1); 318 return (1);
319 } 319 }
320 val = HDLC_FLAG_VALUE; 320 val = HDLC_FLAG_VALUE;
321 for (j=0; j<8; j++) { 321 for (j = 0; j < 8; j++) {
322 bitcnt++; 322 bitcnt++;
323 s_val >>= 1; 323 s_val >>= 1;
324 if (val & 1) 324 if (val & 1)
325 s_val |= 0x80; 325 s_val |= 0x80;
326 else 326 else
327 s_val &= 0x7f; 327 s_val &= 0x7f;
328 if (bitcnt==7) { 328 if (bitcnt == 7) {
329 s_val >>= 1; 329 s_val >>= 1;
330 s_val |= 0x80; 330 s_val |= 0x80;
331 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; 331 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
@@ -334,25 +334,25 @@ static int make_raw_data_56k(struct BCState *bcs) {
334 val >>= 1; 334 val >>= 1;
335 }; 335 };
336 fcs = PPP_INITFCS; 336 fcs = PPP_INITFCS;
337 for (i=0; i<bcs->tx_skb->len; i++) { 337 for (i = 0; i < bcs->tx_skb->len; i++) {
338 val = bcs->tx_skb->data[i]; 338 val = bcs->tx_skb->data[i];
339 fcs = PPP_FCS (fcs, val); 339 fcs = PPP_FCS(fcs, val);
340 MAKE_RAW_BYTE_56K; 340 MAKE_RAW_BYTE_56K;
341 } 341 }
342 fcs ^= 0xffff; 342 fcs ^= 0xffff;
343 val = fcs & 0xff; 343 val = fcs & 0xff;
344 MAKE_RAW_BYTE_56K; 344 MAKE_RAW_BYTE_56K;
345 val = (fcs>>8) & 0xff; 345 val = (fcs >> 8) & 0xff;
346 MAKE_RAW_BYTE_56K; 346 MAKE_RAW_BYTE_56K;
347 val = HDLC_FLAG_VALUE; 347 val = HDLC_FLAG_VALUE;
348 for (j=0; j<8; j++) { 348 for (j = 0; j < 8; j++) {
349 bitcnt++; 349 bitcnt++;
350 s_val >>= 1; 350 s_val >>= 1;
351 if (val & 1) 351 if (val & 1)
352 s_val |= 0x80; 352 s_val |= 0x80;
353 else 353 else
354 s_val &= 0x7f; 354 s_val &= 0x7f;
355 if (bitcnt==7) { 355 if (bitcnt == 7) {
356 s_val >>= 1; 356 s_val >>= 1;
357 s_val |= 0x80; 357 s_val |= 0x80;
358 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; 358 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
@@ -361,10 +361,10 @@ static int make_raw_data_56k(struct BCState *bcs) {
361 val >>= 1; 361 val >>= 1;
362 } 362 }
363 if (bcs->cs->debug & L1_DEB_HSCX) 363 if (bcs->cs->debug & L1_DEB_HSCX)
364 debugl1(bcs->cs,"tiger make_raw_56k: in %u out %d.%d", 364 debugl1(bcs->cs, "tiger make_raw_56k: in %u out %d.%d",
365 bcs->tx_skb->len, s_cnt, bitcnt); 365 bcs->tx_skb->len, s_cnt, bitcnt);
366 if (bitcnt) { 366 if (bitcnt) {
367 while (8>bitcnt++) { 367 while (8 > bitcnt++) {
368 s_val >>= 1; 368 s_val >>= 1;
369 s_val |= 0x80; 369 s_val |= 0x80;
370 } 370 }
@@ -374,12 +374,12 @@ static int make_raw_data_56k(struct BCState *bcs) {
374 bcs->hw.tiger.sendcnt = s_cnt; 374 bcs->hw.tiger.sendcnt = s_cnt;
375 bcs->tx_cnt -= bcs->tx_skb->len; 375 bcs->tx_cnt -= bcs->tx_skb->len;
376 bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf; 376 bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
377 return(0); 377 return (0);
378} 378}
379 379
380static void got_frame(struct BCState *bcs, int count) { 380static void got_frame(struct BCState *bcs, int count) {
381 struct sk_buff *skb; 381 struct sk_buff *skb;
382 382
383 if (!(skb = dev_alloc_skb(count))) 383 if (!(skb = dev_alloc_skb(count)))
384 printk(KERN_WARNING "TIGER: receive out of memory\n"); 384 printk(KERN_WARNING "TIGER: receive out of memory\n");
385 else { 385 else {
@@ -388,18 +388,18 @@ static void got_frame(struct BCState *bcs, int count) {
388 } 388 }
389 test_and_set_bit(B_RCVBUFREADY, &bcs->event); 389 test_and_set_bit(B_RCVBUFREADY, &bcs->event);
390 schedule_work(&bcs->tqueue); 390 schedule_work(&bcs->tqueue);
391 391
392 if (bcs->cs->debug & L1_DEB_RECEIVE_FRAME) 392 if (bcs->cs->debug & L1_DEB_RECEIVE_FRAME)
393 printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, "rec"); 393 printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, "rec");
394} 394}
395 395
396 396
397 397
398static void read_raw(struct BCState *bcs, u_int *buf, int cnt){ 398static void read_raw(struct BCState *bcs, u_int *buf, int cnt) {
399 int i; 399 int i;
400 register u_char j; 400 register u_char j;
401 register u_char val; 401 register u_char val;
402 u_int *pend = bcs->hw.tiger.rec +NETJET_DMA_RXSIZE -1; 402 u_int *pend = bcs->hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
403 register u_char state = bcs->hw.tiger.r_state; 403 register u_char state = bcs->hw.tiger.r_state;
404 register u_char r_one = bcs->hw.tiger.r_one; 404 register u_char r_one = bcs->hw.tiger.r_one;
405 register u_char r_val = bcs->hw.tiger.r_val; 405 register u_char r_val = bcs->hw.tiger.r_val;
@@ -408,7 +408,7 @@ static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
408 int bits; 408 int bits;
409 u_char mask; 409 u_char mask;
410 410
411 if (bcs->mode == L1_MODE_HDLC) { // it's 64k 411 if (bcs->mode == L1_MODE_HDLC) { // it's 64k
412 mask = 0xff; 412 mask = 0xff;
413 bits = 8; 413 bits = 8;
414 } 414 }
@@ -416,8 +416,8 @@ static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
416 mask = 0x7f; 416 mask = 0x7f;
417 bits = 7; 417 bits = 7;
418 }; 418 };
419 for (i=0;i<cnt;i++) { 419 for (i = 0; i < cnt; i++) {
420 val = bcs->channel ? ((*p>>8) & 0xff) : (*p & 0xff); 420 val = bcs->channel ? ((*p >> 8) & 0xff) : (*p & 0xff);
421 p++; 421 p++;
422 if (p > pend) 422 if (p > pend)
423 p = bcs->hw.tiger.rec; 423 p = bcs->hw.tiger.rec;
@@ -428,137 +428,137 @@ static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
428 r_one = 0; 428 r_one = 0;
429 continue; 429 continue;
430 } 430 }
431 for (j=0;j<bits;j++) { 431 for (j = 0; j < bits; j++) {
432 if (state == HDLC_ZERO_SEARCH) { 432 if (state == HDLC_ZERO_SEARCH) {
433 if (val & 1) { 433 if (val & 1) {
434 r_one++; 434 r_one++;
435 } else { 435 } else {
436 r_one=0; 436 r_one = 0;
437 state= HDLC_FLAG_SEARCH; 437 state = HDLC_FLAG_SEARCH;
438 if (bcs->cs->debug & L1_DEB_HSCX) 438 if (bcs->cs->debug & L1_DEB_HSCX)
439 debugl1(bcs->cs,"tiger read_raw: zBit(%d,%d,%d) %x", 439 debugl1(bcs->cs, "tiger read_raw: zBit(%d,%d,%d) %x",
440 bcs->hw.tiger.r_tot,i,j,val); 440 bcs->hw.tiger.r_tot, i, j, val);
441 } 441 }
442 } else if (state == HDLC_FLAG_SEARCH) { 442 } else if (state == HDLC_FLAG_SEARCH) {
443 if (val & 1) { 443 if (val & 1) {
444 r_one++; 444 r_one++;
445 if (r_one>6) { 445 if (r_one > 6) {
446 state=HDLC_ZERO_SEARCH; 446 state = HDLC_ZERO_SEARCH;
447 } 447 }
448 } else { 448 } else {
449 if (r_one==6) { 449 if (r_one == 6) {
450 bitcnt=0; 450 bitcnt = 0;
451 r_val=0; 451 r_val = 0;
452 state=HDLC_FLAG_FOUND; 452 state = HDLC_FLAG_FOUND;
453 if (bcs->cs->debug & L1_DEB_HSCX) 453 if (bcs->cs->debug & L1_DEB_HSCX)
454 debugl1(bcs->cs,"tiger read_raw: flag(%d,%d,%d) %x", 454 debugl1(bcs->cs, "tiger read_raw: flag(%d,%d,%d) %x",
455 bcs->hw.tiger.r_tot,i,j,val); 455 bcs->hw.tiger.r_tot, i, j, val);
456 } 456 }
457 r_one=0; 457 r_one = 0;
458 } 458 }
459 } else if (state == HDLC_FLAG_FOUND) { 459 } else if (state == HDLC_FLAG_FOUND) {
460 if (val & 1) { 460 if (val & 1) {
461 r_one++; 461 r_one++;
462 if (r_one>6) { 462 if (r_one > 6) {
463 state=HDLC_ZERO_SEARCH; 463 state = HDLC_ZERO_SEARCH;
464 } else { 464 } else {
465 r_val >>= 1; 465 r_val >>= 1;
466 r_val |= 0x80; 466 r_val |= 0x80;
467 bitcnt++; 467 bitcnt++;
468 } 468 }
469 } else { 469 } else {
470 if (r_one==6) { 470 if (r_one == 6) {
471 bitcnt=0; 471 bitcnt = 0;
472 r_val=0; 472 r_val = 0;
473 r_one=0; 473 r_one = 0;
474 val >>= 1; 474 val >>= 1;
475 continue; 475 continue;
476 } else if (r_one!=5) { 476 } else if (r_one != 5) {
477 r_val >>= 1; 477 r_val >>= 1;
478 r_val &= 0x7f; 478 r_val &= 0x7f;
479 bitcnt++; 479 bitcnt++;
480 } 480 }
481 r_one=0; 481 r_one = 0;
482 } 482 }
483 if ((state != HDLC_ZERO_SEARCH) && 483 if ((state != HDLC_ZERO_SEARCH) &&
484 !(bitcnt & 7)) { 484 !(bitcnt & 7)) {
485 state=HDLC_FRAME_FOUND; 485 state = HDLC_FRAME_FOUND;
486 bcs->hw.tiger.r_fcs = PPP_INITFCS; 486 bcs->hw.tiger.r_fcs = PPP_INITFCS;
487 bcs->hw.tiger.rcvbuf[0] = r_val; 487 bcs->hw.tiger.rcvbuf[0] = r_val;
488 bcs->hw.tiger.r_fcs = PPP_FCS (bcs->hw.tiger.r_fcs, r_val); 488 bcs->hw.tiger.r_fcs = PPP_FCS(bcs->hw.tiger.r_fcs, r_val);
489 if (bcs->cs->debug & L1_DEB_HSCX) 489 if (bcs->cs->debug & L1_DEB_HSCX)
490 debugl1(bcs->cs,"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x", 490 debugl1(bcs->cs, "tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x",
491 bcs->hw.tiger.r_tot,i,j,r_val,val, 491 bcs->hw.tiger.r_tot, i, j, r_val, val,
492 bcs->cs->hw.njet.irqstat0); 492 bcs->cs->hw.njet.irqstat0);
493 } 493 }
494 } else if (state == HDLC_FRAME_FOUND) { 494 } else if (state == HDLC_FRAME_FOUND) {
495 if (val & 1) { 495 if (val & 1) {
496 r_one++; 496 r_one++;
497 if (r_one>6) { 497 if (r_one > 6) {
498 state=HDLC_ZERO_SEARCH; 498 state = HDLC_ZERO_SEARCH;
499 bitcnt=0; 499 bitcnt = 0;
500 } else { 500 } else {
501 r_val >>= 1; 501 r_val >>= 1;
502 r_val |= 0x80; 502 r_val |= 0x80;
503 bitcnt++; 503 bitcnt++;
504 } 504 }
505 } else { 505 } else {
506 if (r_one==6) { 506 if (r_one == 6) {
507 r_val=0; 507 r_val = 0;
508 r_one=0; 508 r_one = 0;
509 bitcnt++; 509 bitcnt++;
510 if (bitcnt & 7) { 510 if (bitcnt & 7) {
511 debugl1(bcs->cs, "tiger: frame not byte aligned"); 511 debugl1(bcs->cs, "tiger: frame not byte aligned");
512 state=HDLC_FLAG_SEARCH; 512 state = HDLC_FLAG_SEARCH;
513 bcs->hw.tiger.r_err++; 513 bcs->hw.tiger.r_err++;
514#ifdef ERROR_STATISTIC 514#ifdef ERROR_STATISTIC
515 bcs->err_inv++; 515 bcs->err_inv++;
516#endif 516#endif
517 } else { 517 } else {
518 if (bcs->cs->debug & L1_DEB_HSCX) 518 if (bcs->cs->debug & L1_DEB_HSCX)
519 debugl1(bcs->cs,"tiger frame end(%d,%d): fcs(%x) i %x", 519 debugl1(bcs->cs, "tiger frame end(%d,%d): fcs(%x) i %x",
520 i,j,bcs->hw.tiger.r_fcs, bcs->cs->hw.njet.irqstat0); 520 i, j, bcs->hw.tiger.r_fcs, bcs->cs->hw.njet.irqstat0);
521 if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) { 521 if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) {
522 got_frame(bcs, (bitcnt>>3)-3); 522 got_frame(bcs, (bitcnt >> 3) - 3);
523 } else { 523 } else {
524 if (bcs->cs->debug) { 524 if (bcs->cs->debug) {
525 debugl1(bcs->cs, "tiger FCS error"); 525 debugl1(bcs->cs, "tiger FCS error");
526 printframe(bcs->cs, bcs->hw.tiger.rcvbuf, 526 printframe(bcs->cs, bcs->hw.tiger.rcvbuf,
527 (bitcnt>>3)-1, "rec"); 527 (bitcnt >> 3) - 1, "rec");
528 bcs->hw.tiger.r_err++; 528 bcs->hw.tiger.r_err++;
529 } 529 }
530#ifdef ERROR_STATISTIC 530#ifdef ERROR_STATISTIC
531 bcs->err_crc++; 531 bcs->err_crc++;
532#endif 532#endif
533 } 533 }
534 state=HDLC_FLAG_FOUND; 534 state = HDLC_FLAG_FOUND;
535 } 535 }
536 bitcnt=0; 536 bitcnt = 0;
537 } else if (r_one==5) { 537 } else if (r_one == 5) {
538 val >>= 1; 538 val >>= 1;
539 r_one=0; 539 r_one = 0;
540 continue; 540 continue;
541 } else { 541 } else {
542 r_val >>= 1; 542 r_val >>= 1;
543 r_val &= 0x7f; 543 r_val &= 0x7f;
544 bitcnt++; 544 bitcnt++;
545 } 545 }
546 r_one=0; 546 r_one = 0;
547 } 547 }
548 if ((state == HDLC_FRAME_FOUND) && 548 if ((state == HDLC_FRAME_FOUND) &&
549 !(bitcnt & 7)) { 549 !(bitcnt & 7)) {
550 if ((bitcnt>>3)>=HSCX_BUFMAX) { 550 if ((bitcnt >> 3) >= HSCX_BUFMAX) {
551 debugl1(bcs->cs, "tiger: frame too big"); 551 debugl1(bcs->cs, "tiger: frame too big");
552 r_val=0; 552 r_val = 0;
553 state=HDLC_FLAG_SEARCH; 553 state = HDLC_FLAG_SEARCH;
554 bcs->hw.tiger.r_err++; 554 bcs->hw.tiger.r_err++;
555#ifdef ERROR_STATISTIC 555#ifdef ERROR_STATISTIC
556 bcs->err_inv++; 556 bcs->err_inv++;
557#endif 557#endif
558 } else { 558 } else {
559 bcs->hw.tiger.rcvbuf[(bitcnt>>3)-1] = r_val; 559 bcs->hw.tiger.rcvbuf[(bitcnt >> 3) - 1] = r_val;
560 bcs->hw.tiger.r_fcs = 560 bcs->hw.tiger.r_fcs =
561 PPP_FCS (bcs->hw.tiger.r_fcs, r_val); 561 PPP_FCS(bcs->hw.tiger.r_fcs, r_val);
562 } 562 }
563 } 563 }
564 } 564 }
@@ -574,10 +574,10 @@ static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
574 574
575void read_tiger(struct IsdnCardState *cs) { 575void read_tiger(struct IsdnCardState *cs) {
576 u_int *p; 576 u_int *p;
577 int cnt = NETJET_DMA_RXSIZE/2; 577 int cnt = NETJET_DMA_RXSIZE / 2;
578 578
579 if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) { 579 if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) {
580 debugl1(cs,"tiger warn read double dma %x/%x", 580 debugl1(cs, "tiger warn read double dma %x/%x",
581 cs->hw.njet.irqstat0, cs->hw.njet.last_is0); 581 cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
582#ifdef ERROR_STATISTIC 582#ifdef ERROR_STATISTIC
583 if (cs->bcs[0].mode) 583 if (cs->bcs[0].mode)
@@ -589,7 +589,7 @@ void read_tiger(struct IsdnCardState *cs) {
589 } else { 589 } else {
590 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ; 590 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ;
591 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ); 591 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ);
592 } 592 }
593 if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1) 593 if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1)
594 p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1; 594 p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
595 else 595 else
@@ -612,20 +612,20 @@ void netjet_fill_dma(struct BCState *bcs)
612 if (!bcs->tx_skb) 612 if (!bcs->tx_skb)
613 return; 613 return;
614 if (bcs->cs->debug & L1_DEB_HSCX) 614 if (bcs->cs->debug & L1_DEB_HSCX)
615 debugl1(bcs->cs,"tiger fill_dma1: c%d %4lx", bcs->channel, 615 debugl1(bcs->cs, "tiger fill_dma1: c%d %4lx", bcs->channel,
616 bcs->Flag); 616 bcs->Flag);
617 if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag)) 617 if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag))
618 return; 618 return;
619 if (bcs->mode == L1_MODE_HDLC) { // it's 64k 619 if (bcs->mode == L1_MODE_HDLC) { // it's 64k
620 if (make_raw_data(bcs)) 620 if (make_raw_data(bcs))
621 return; 621 return;
622 } 622 }
623 else { // it's 56k 623 else { // it's 56k
624 if (make_raw_data_56k(bcs)) 624 if (make_raw_data_56k(bcs))
625 return; 625 return;
626 }; 626 };
627 if (bcs->cs->debug & L1_DEB_HSCX) 627 if (bcs->cs->debug & L1_DEB_HSCX)
628 debugl1(bcs->cs,"tiger fill_dma2: c%d %4lx", bcs->channel, 628 debugl1(bcs->cs, "tiger fill_dma2: c%d %4lx", bcs->channel,
629 bcs->Flag); 629 bcs->Flag);
630 if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) { 630 if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
631 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free); 631 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
@@ -633,11 +633,11 @@ void netjet_fill_dma(struct BCState *bcs)
633 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR)); 633 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
634 sp = bcs->hw.tiger.sendp; 634 sp = bcs->hw.tiger.sendp;
635 if (p == bcs->hw.tiger.s_end) 635 if (p == bcs->hw.tiger.s_end)
636 p = bcs->hw.tiger.send -1; 636 p = bcs->hw.tiger.send - 1;
637 if (sp == bcs->hw.tiger.s_end) 637 if (sp == bcs->hw.tiger.s_end)
638 sp = bcs->hw.tiger.send -1; 638 sp = bcs->hw.tiger.send - 1;
639 cnt = p - sp; 639 cnt = p - sp;
640 if (cnt <0) { 640 if (cnt < 0) {
641 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free); 641 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
642 } else { 642 } else {
643 p++; 643 p++;
@@ -655,30 +655,30 @@ void netjet_fill_dma(struct BCState *bcs)
655 cnt = bcs->hw.tiger.s_end - p; 655 cnt = bcs->hw.tiger.s_end - p;
656 if (cnt < 2) { 656 if (cnt < 2) {
657 p = bcs->hw.tiger.send + 1; 657 p = bcs->hw.tiger.send + 1;
658 cnt = NETJET_DMA_TXSIZE/2 - 2; 658 cnt = NETJET_DMA_TXSIZE / 2 - 2;
659 } else { 659 } else {
660 p++; 660 p++;
661 p++; 661 p++;
662 if (cnt <= (NETJET_DMA_TXSIZE/2)) 662 if (cnt <= (NETJET_DMA_TXSIZE / 2))
663 cnt += NETJET_DMA_TXSIZE/2; 663 cnt += NETJET_DMA_TXSIZE / 2;
664 cnt--; 664 cnt--;
665 cnt--; 665 cnt--;
666 } 666 }
667 write_raw(bcs, p, cnt); 667 write_raw(bcs, p, cnt);
668 } 668 }
669 if (bcs->cs->debug & L1_DEB_HSCX) 669 if (bcs->cs->debug & L1_DEB_HSCX)
670 debugl1(bcs->cs,"tiger fill_dma3: c%d %4lx", bcs->channel, 670 debugl1(bcs->cs, "tiger fill_dma3: c%d %4lx", bcs->channel,
671 bcs->Flag); 671 bcs->Flag);
672} 672}
673 673
674static void write_raw(struct BCState *bcs, u_int *buf, int cnt) { 674static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
675 u_int mask, val, *p=buf; 675 u_int mask, val, *p = buf;
676 u_int i, s_cnt; 676 u_int i, s_cnt;
677 677
678 if (cnt <= 0) 678 if (cnt <= 0)
679 return; 679 return;
680 if (test_bit(BC_FLG_BUSY, &bcs->Flag)) { 680 if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
681 if (bcs->hw.tiger.sendcnt> cnt) { 681 if (bcs->hw.tiger.sendcnt > cnt) {
682 s_cnt = cnt; 682 s_cnt = cnt;
683 bcs->hw.tiger.sendcnt -= cnt; 683 bcs->hw.tiger.sendcnt -= cnt;
684 } else { 684 } else {
@@ -689,17 +689,17 @@ static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
689 mask = 0xffff00ff; 689 mask = 0xffff00ff;
690 else 690 else
691 mask = 0xffffff00; 691 mask = 0xffffff00;
692 for (i=0; i<s_cnt; i++) { 692 for (i = 0; i < s_cnt; i++) {
693 val = bcs->channel ? ((bcs->hw.tiger.sp[i] <<8) & 0xff00) : 693 val = bcs->channel ? ((bcs->hw.tiger.sp[i] << 8) & 0xff00) :
694 (bcs->hw.tiger.sp[i]); 694 (bcs->hw.tiger.sp[i]);
695 *p &= mask; 695 *p &= mask;
696 *p++ |= val; 696 *p++ |= val;
697 if (p>bcs->hw.tiger.s_end) 697 if (p > bcs->hw.tiger.s_end)
698 p = bcs->hw.tiger.send; 698 p = bcs->hw.tiger.send;
699 } 699 }
700 bcs->hw.tiger.s_tot += s_cnt; 700 bcs->hw.tiger.s_tot += s_cnt;
701 if (bcs->cs->debug & L1_DEB_HSCX) 701 if (bcs->cs->debug & L1_DEB_HSCX)
702 debugl1(bcs->cs,"tiger write_raw: c%d %p-%p %d/%d %d %x", bcs->channel, 702 debugl1(bcs->cs, "tiger write_raw: c%d %p-%p %d/%d %d %x", bcs->channel,
703 buf, p, s_cnt, cnt, 703 buf, p, s_cnt, cnt,
704 bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0); 704 bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0);
705 if (bcs->cs->debug & L1_DEB_HSCX_FIFO) 705 if (bcs->cs->debug & L1_DEB_HSCX_FIFO)
@@ -708,10 +708,10 @@ static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
708 bcs->hw.tiger.sendp = p; 708 bcs->hw.tiger.sendp = p;
709 if (!bcs->hw.tiger.sendcnt) { 709 if (!bcs->hw.tiger.sendcnt) {
710 if (!bcs->tx_skb) { 710 if (!bcs->tx_skb) {
711 debugl1(bcs->cs,"tiger write_raw: NULL skb s_cnt %d", s_cnt); 711 debugl1(bcs->cs, "tiger write_raw: NULL skb s_cnt %d", s_cnt);
712 } else { 712 } else {
713 if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag) && 713 if (test_bit(FLG_LLI_L1WAKEUP, &bcs->st->lli.flag) &&
714 (PACKET_NOACK != bcs->tx_skb->pkt_type)) { 714 (PACKET_NOACK != bcs->tx_skb->pkt_type)) {
715 u_long flags; 715 u_long flags;
716 spin_lock_irqsave(&bcs->aclock, flags); 716 spin_lock_irqsave(&bcs->aclock, flags);
717 bcs->ackcnt += bcs->tx_skb->len; 717 bcs->ackcnt += bcs->tx_skb->len;
@@ -723,7 +723,7 @@ static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
723 } 723 }
724 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag); 724 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
725 bcs->hw.tiger.free = cnt - s_cnt; 725 bcs->hw.tiger.free = cnt - s_cnt;
726 if (bcs->hw.tiger.free > (NETJET_DMA_TXSIZE/2)) 726 if (bcs->hw.tiger.free > (NETJET_DMA_TXSIZE / 2))
727 test_and_set_bit(BC_FLG_HALF, &bcs->Flag); 727 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
728 else { 728 else {
729 test_and_clear_bit(BC_FLG_HALF, &bcs->Flag); 729 test_and_clear_bit(BC_FLG_HALF, &bcs->Flag);
@@ -734,9 +734,9 @@ static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
734 } else { 734 } else {
735 mask ^= 0xffffffff; 735 mask ^= 0xffffffff;
736 if (s_cnt < cnt) { 736 if (s_cnt < cnt) {
737 for (i=s_cnt; i<cnt;i++) { 737 for (i = s_cnt; i < cnt; i++) {
738 *p++ |= mask; 738 *p++ |= mask;
739 if (p>bcs->hw.tiger.s_end) 739 if (p > bcs->hw.tiger.s_end)
740 p = bcs->hw.tiger.send; 740 p = bcs->hw.tiger.send;
741 } 741 }
742 if (bcs->cs->debug & L1_DEB_HSCX) 742 if (bcs->cs->debug & L1_DEB_HSCX)
@@ -752,20 +752,20 @@ static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
752 fill_mem(bcs, buf, cnt, bcs->channel, 0xff); 752 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
753 bcs->hw.tiger.free += cnt; 753 bcs->hw.tiger.free += cnt;
754 if (bcs->cs->debug & L1_DEB_HSCX) 754 if (bcs->cs->debug & L1_DEB_HSCX)
755 debugl1(bcs->cs,"tiger write_raw: fill half"); 755 debugl1(bcs->cs, "tiger write_raw: fill half");
756 } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) { 756 } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
757 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag); 757 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
758 fill_mem(bcs, buf, cnt, bcs->channel, 0xff); 758 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
759 if (bcs->cs->debug & L1_DEB_HSCX) 759 if (bcs->cs->debug & L1_DEB_HSCX)
760 debugl1(bcs->cs,"tiger write_raw: fill full"); 760 debugl1(bcs->cs, "tiger write_raw: fill full");
761 } 761 }
762} 762}
763 763
764void write_tiger(struct IsdnCardState *cs) { 764void write_tiger(struct IsdnCardState *cs) {
765 u_int *p, cnt = NETJET_DMA_TXSIZE/2; 765 u_int *p, cnt = NETJET_DMA_TXSIZE / 2;
766 766
767 if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) { 767 if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) {
768 debugl1(cs,"tiger warn write double dma %x/%x", 768 debugl1(cs, "tiger warn write double dma %x/%x",
769 cs->hw.njet.irqstat0, cs->hw.njet.last_is0); 769 cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
770#ifdef ERROR_STATISTIC 770#ifdef ERROR_STATISTIC
771 if (cs->bcs[0].mode) 771 if (cs->bcs[0].mode)
@@ -777,7 +777,7 @@ void write_tiger(struct IsdnCardState *cs) {
777 } else { 777 } else {
778 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE; 778 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE;
779 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE); 779 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE);
780 } 780 }
781 if (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE_1) 781 if (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE_1)
782 p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1; 782 p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
783 else 783 else
@@ -797,55 +797,55 @@ tiger_l2l1(struct PStack *st, int pr, void *arg)
797 u_long flags; 797 u_long flags;
798 798
799 switch (pr) { 799 switch (pr) {
800 case (PH_DATA | REQUEST): 800 case (PH_DATA | REQUEST):
801 spin_lock_irqsave(&bcs->cs->lock, flags); 801 spin_lock_irqsave(&bcs->cs->lock, flags);
802 if (bcs->tx_skb) { 802 if (bcs->tx_skb) {
803 skb_queue_tail(&bcs->squeue, skb); 803 skb_queue_tail(&bcs->squeue, skb);
804 } else { 804 } else {
805 bcs->tx_skb = skb; 805 bcs->tx_skb = skb;
806 bcs->cs->BC_Send_Data(bcs); 806 bcs->cs->BC_Send_Data(bcs);
807 } 807 }
808 spin_unlock_irqrestore(&bcs->cs->lock, flags); 808 spin_unlock_irqrestore(&bcs->cs->lock, flags);
809 break; 809 break;
810 case (PH_PULL | INDICATION): 810 case (PH_PULL | INDICATION):
811 spin_lock_irqsave(&bcs->cs->lock, flags); 811 spin_lock_irqsave(&bcs->cs->lock, flags);
812 if (bcs->tx_skb) { 812 if (bcs->tx_skb) {
813 printk(KERN_WARNING "tiger_l2l1: this shouldn't happen\n"); 813 printk(KERN_WARNING "tiger_l2l1: this shouldn't happen\n");
814 } else { 814 } else {
815 bcs->tx_skb = skb; 815 bcs->tx_skb = skb;
816 bcs->cs->BC_Send_Data(bcs); 816 bcs->cs->BC_Send_Data(bcs);
817 } 817 }
818 spin_unlock_irqrestore(&bcs->cs->lock, flags); 818 spin_unlock_irqrestore(&bcs->cs->lock, flags);
819 break; 819 break;
820 case (PH_PULL | REQUEST): 820 case (PH_PULL | REQUEST):
821 if (!bcs->tx_skb) { 821 if (!bcs->tx_skb) {
822 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags); 822 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
823 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL); 823 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
824 } else 824 } else
825 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags); 825 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
826 break; 826 break;
827 case (PH_ACTIVATE | REQUEST): 827 case (PH_ACTIVATE | REQUEST):
828 spin_lock_irqsave(&bcs->cs->lock, flags); 828 spin_lock_irqsave(&bcs->cs->lock, flags);
829 test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag); 829 test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
830 mode_tiger(bcs, st->l1.mode, st->l1.bc); 830 mode_tiger(bcs, st->l1.mode, st->l1.bc);
831 /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */ 831 /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
832 spin_unlock_irqrestore(&bcs->cs->lock, flags); 832 spin_unlock_irqrestore(&bcs->cs->lock, flags);
833 bcs->cs->cardmsg(bcs->cs, MDL_BC_ASSIGN, (void *)(&st->l1.bc)); 833 bcs->cs->cardmsg(bcs->cs, MDL_BC_ASSIGN, (void *)(&st->l1.bc));
834 l1_msg_b(st, pr, arg); 834 l1_msg_b(st, pr, arg);
835 break; 835 break;
836 case (PH_DEACTIVATE | REQUEST): 836 case (PH_DEACTIVATE | REQUEST):
837 /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */ 837 /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
838 bcs->cs->cardmsg(bcs->cs, MDL_BC_RELEASE, (void *)(&st->l1.bc)); 838 bcs->cs->cardmsg(bcs->cs, MDL_BC_RELEASE, (void *)(&st->l1.bc));
839 l1_msg_b(st, pr, arg); 839 l1_msg_b(st, pr, arg);
840 break; 840 break;
841 case (PH_DEACTIVATE | CONFIRM): 841 case (PH_DEACTIVATE | CONFIRM):
842 spin_lock_irqsave(&bcs->cs->lock, flags); 842 spin_lock_irqsave(&bcs->cs->lock, flags);
843 test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag); 843 test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
844 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag); 844 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
845 mode_tiger(bcs, 0, st->l1.bc); 845 mode_tiger(bcs, 0, st->l1.bc);
846 spin_unlock_irqrestore(&bcs->cs->lock, flags); 846 spin_unlock_irqrestore(&bcs->cs->lock, flags);
847 st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL); 847 st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
848 break; 848 break;
849 } 849 }
850} 850}
851 851
@@ -908,33 +908,33 @@ setstack_tiger(struct PStack *st, struct BCState *bcs)
908 return (0); 908 return (0);
909} 909}
910 910
911 911
912void 912void
913inittiger(struct IsdnCardState *cs) 913inittiger(struct IsdnCardState *cs)
914{ 914{
915 if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int), 915 if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int),
916 GFP_KERNEL | GFP_DMA))) { 916 GFP_KERNEL | GFP_DMA))) {
917 printk(KERN_WARNING 917 printk(KERN_WARNING
918 "HiSax: No memory for tiger.send\n"); 918 "HiSax: No memory for tiger.send\n");
919 return; 919 return;
920 } 920 }
921 cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE/2 - 1; 921 cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE / 2 - 1;
922 cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1; 922 cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
923 cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send; 923 cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send;
924 cs->bcs[1].hw.tiger.s_irq = cs->bcs[0].hw.tiger.s_irq; 924 cs->bcs[1].hw.tiger.s_irq = cs->bcs[0].hw.tiger.s_irq;
925 cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end; 925 cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end;
926 926
927 memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_TXSIZE * sizeof(unsigned int)); 927 memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_TXSIZE * sizeof(unsigned int));
928 debugl1(cs, "tiger: send buf %p - %p", cs->bcs[0].hw.tiger.send, 928 debugl1(cs, "tiger: send buf %p - %p", cs->bcs[0].hw.tiger.send,
929 cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1); 929 cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1);
930 outl(virt_to_bus(cs->bcs[0].hw.tiger.send), 930 outl(virt_to_bus(cs->bcs[0].hw.tiger.send),
931 cs->hw.njet.base + NETJET_DMA_READ_START); 931 cs->hw.njet.base + NETJET_DMA_READ_START);
932 outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq), 932 outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq),
933 cs->hw.njet.base + NETJET_DMA_READ_IRQ); 933 cs->hw.njet.base + NETJET_DMA_READ_IRQ);
934 outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end), 934 outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end),
935 cs->hw.njet.base + NETJET_DMA_READ_END); 935 cs->hw.njet.base + NETJET_DMA_READ_END);
936 if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int), 936 if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int),
937 GFP_KERNEL | GFP_DMA))) { 937 GFP_KERNEL | GFP_DMA))) {
938 printk(KERN_WARNING 938 printk(KERN_WARNING
939 "HiSax: No memory for tiger.rec\n"); 939 "HiSax: No memory for tiger.rec\n");
940 return; 940 return;
@@ -944,11 +944,11 @@ inittiger(struct IsdnCardState *cs)
944 cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec; 944 cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec;
945 memset(cs->bcs[0].hw.tiger.rec, 0xff, NETJET_DMA_RXSIZE * sizeof(unsigned int)); 945 memset(cs->bcs[0].hw.tiger.rec, 0xff, NETJET_DMA_RXSIZE * sizeof(unsigned int));
946 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec), 946 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec),
947 cs->hw.njet.base + NETJET_DMA_WRITE_START); 947 cs->hw.njet.base + NETJET_DMA_WRITE_START);
948 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE/2 - 1), 948 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE / 2 - 1),
949 cs->hw.njet.base + NETJET_DMA_WRITE_IRQ); 949 cs->hw.njet.base + NETJET_DMA_WRITE_IRQ);
950 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1), 950 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1),
951 cs->hw.njet.base + NETJET_DMA_WRITE_END); 951 cs->hw.njet.base + NETJET_DMA_WRITE_END);
952 debugl1(cs, "tiger: dmacfg %x/%x pulse=%d", 952 debugl1(cs, "tiger: dmacfg %x/%x pulse=%d",
953 inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR), 953 inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
954 inl(cs->hw.njet.base + NETJET_DMA_READ_ADR), 954 inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
@@ -979,4 +979,3 @@ release_io_netjet(struct IsdnCardState *cs)
979 releasetiger(cs); 979 releasetiger(cs);
980 release_region(cs->hw.njet.base, 256); 980 release_region(cs->hw.njet.base, 256);
981} 981}
982
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-10 00:00:21 -0500