projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
RDMA/iw_cxgb4: calculate t4_eq_status_entries properly
[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / drivers / isdn / hisax / netjet.c
CommitLineData
1da177e4
LT		 1/* $Id: netjet.c,v 1.29.2.4 2004/02/11 13:21:34 keil Exp $
2 *
3 * low level stuff for Traverse Technologie NETJet ISDN cards
4 *
5 * Author Karsten Keil
6 * Copyright by Karsten Keil <keil@isdn4linux.de>
475be4d8 7 *
1da177e4
LT		 8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Thanks to Traverse Technologies Australia for documents and information
12 *
13 * 16-Apr-2002 - led code added - Guy Ellis (guy@traverse.com.au)
14 *
15 */
16
17#include <linux/init.h>
18#include "hisax.h"
19#include "isac.h"
20#include "hscx.h"
21#include "isdnl1.h"
1da177e4
LT		 22#include <linux/interrupt.h>
23#include <linux/ppp_defs.h>
5a0e3ad6 24#include <linux/slab.h>
1da177e4
LT		 25#include <asm/io.h>
26#include "netjet.h"
27
1da177e4
LT		 28/* Interface functions */
29
30u_char
31NETjet_ReadIC(struct IsdnCardState *cs, u_char offset)
32{
33 u_char ret;
475be4d8 34
1da177e4 35 cs->hw.njet.auxd &= 0xfc;
475be4d8 36 cs->hw.njet.auxd |= (offset >> 4) & 3;
1da177e4 37 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
475be4d8
JP		 38 ret = bytein(cs->hw.njet.isac + ((offset & 0xf) << 2));
39 return (ret);
1da177e4
LT		 40}
41
42void
43NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value)
44{
45 cs->hw.njet.auxd &= 0xfc;
475be4d8 46 cs->hw.njet.auxd |= (offset >> 4) & 3;
1da177e4 47 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
475be4d8 48 byteout(cs->hw.njet.isac + ((offset & 0xf) << 2), value);
1da177e4
LT		 49}
50
51void
52NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size)
53{
54 cs->hw.njet.auxd &= 0xfc;
55 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
56 insb(cs->hw.njet.isac, data, size);
57}
58
475be4d8 59void
1da177e4
LT		 60NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
61{
62 cs->hw.njet.auxd &= 0xfc;
63 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
64 outsb(cs->hw.njet.isac, data, size);
65}
66
672c3fd9 67static void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill)
1da177e4 68{
475be4d8 69 u_int mask = 0x000000ff, val = 0, *p = pos;
1da177e4 70 u_int i;
475be4d8 71
1da177e4
LT		 72 val |= fill;
73 if (chan) {
74 val <<= 8;
75 mask <<= 8;
76 }
77 mask ^= 0xffffffff;
475be4d8
JP		 78 for (i = 0; i < cnt; i++) {
79 *p &= mask;
1da177e4
LT		 80 *p++ |= val;
81 if (p > bcs->hw.tiger.s_end)
82 p = bcs->hw.tiger.send;
83 }
84}
85
672c3fd9 86static void
1da177e4
LT		 87mode_tiger(struct BCState *bcs, int mode, int bc)
88{
89 struct IsdnCardState *cs = bcs->cs;
475be4d8 90 u_char led;
1da177e4
LT		 91
92 if (cs->debug & L1_DEB_HSCX)
93 debugl1(cs, "Tiger mode %d bchan %d/%d",
94 mode, bc, bcs->channel);
95 bcs->mode = mode;
96 bcs->channel = bc;
97 switch (mode) {
475be4d8
JP		 98 case (L1_MODE_NULL):
99 fill_mem(bcs, bcs->hw.tiger.send,
100 NETJET_DMA_TXSIZE, bc, 0xff);
101 if (cs->debug & L1_DEB_HSCX)
102 debugl1(cs, "Tiger stat rec %d/%d send %d",
103 bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err,
104 bcs->hw.tiger.s_tot);
105 if ((cs->bcs[0].mode == L1_MODE_NULL) &&
106 (cs->bcs[1].mode == L1_MODE_NULL)) {
107 cs->hw.njet.dmactrl = 0;
108 byteout(cs->hw.njet.base + NETJET_DMACTRL,
109 cs->hw.njet.dmactrl);
110 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
111 }
112 if (cs->typ == ISDN_CTYPE_NETJET_S)
113 {
114 // led off
115 led = bc & 0x01;
116 led = 0x01 << (6 + led); // convert to mask
117 led = ~led;
118 cs->hw.njet.auxd &= led;
119 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
120 }
121 break;
122 case (L1_MODE_TRANS):
123 break;
124 case (L1_MODE_HDLC_56K):
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) {
1da177e4 135 fill_mem(bcs, bcs->hw.tiger.send,
475be4d8
JP		 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);
1da177e4 141 /* was 0x3f now 0x0f for TJ300 and TJ320 GE 13/07/00 */
475be4d8
JP		 142 }
143 bcs->hw.tiger.sendp = bcs->hw.tiger.send;
144 bcs->hw.tiger.free = NETJET_DMA_TXSIZE;
145 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
146 if (cs->typ == ISDN_CTYPE_NETJET_S)
147 {
148 // led on
149 led = bc & 0x01;
150 led = 0x01 << (6 + led); // convert to mask
151 cs->hw.njet.auxd |= led;
152 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
153 }
154 break;
1da177e4
LT		 155 }
156 if (cs->debug & L1_DEB_HSCX)
157 debugl1(cs, "tiger: set %x %x %x %x/%x pulse=%d",
158 bytein(cs->hw.njet.base + NETJET_DMACTRL),
159 bytein(cs->hw.njet.base + NETJET_IRQMASK0),
160 bytein(cs->hw.njet.base + NETJET_IRQSTAT0),
161 inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
162 inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
163 bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
164}
165
166static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s) {
167 char tmp[128];
168 char *t = tmp;
475be4d8 169 int i = count, j;
1da177e4
LT		 170 u_char *p = buf;
171
172 t += sprintf(t, "tiger %s(%4d)", s, count);
475be4d8
JP		 173 while (i > 0) {
174 if (i > 16)
175 j = 16;
1da177e4 176 else
475be4d8 177 j = i;
1da177e4 178 QuickHex(t, p, j);
35a4a573 179 debugl1(cs, "%s", tmp);
1da177e4
LT		 180 p += j;
181 i -= j;
182 t = tmp;
183 t += sprintf(t, "tiger %s ", s);
184 }
185}
186
187// macro for 64k
188
475be4d8
JP		 189#define MAKE_RAW_BYTE for (j = 0; j < 8; j++) { \
190 bitcnt++; \
191 s_val >>= 1; \
192 if (val & 1) { \
193 s_one++; \
194 s_val |= 0x80; \
195 } else { \
196 s_one = 0; \
197 s_val &= 0x7f; \
198 } \
199 if (bitcnt == 8) { \
200 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
201 bitcnt = 0; \
202 } \
203 if (s_one == 5) { \
204 s_val >>= 1; \
205 s_val &= 0x7f; \
206 bitcnt++; \
207 s_one = 0; \
208 } \
209 if (bitcnt == 8) { \
210 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
211 bitcnt = 0; \
212 } \
213 val >>= 1; \
214 }
1da177e4
LT		 215
216static int make_raw_data(struct BCState *bcs) {
217// this make_raw is for 64k
475be4d8 218 register u_int i, s_cnt = 0;
1da177e4
LT		 219 register u_char j;
220 register u_char val;
221 register u_char s_one = 0;
222 register u_char s_val = 0;
223 register u_char bitcnt = 0;
224 u_int fcs;
475be4d8 225
1da177e4
LT		 226 if (!bcs->tx_skb) {
227 debugl1(bcs->cs, "tiger make_raw: NULL skb");
475be4d8 228 return (1);
1da177e4
LT		 229 }
230 bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE;
231 fcs = PPP_INITFCS;
475be4d8 232 for (i = 0; i < bcs->tx_skb->len; i++) {
1da177e4 233 val = bcs->tx_skb->data[i];
475be4d8 234 fcs = PPP_FCS(fcs, val);
1da177e4
LT		 235 MAKE_RAW_BYTE;
236 }
237 fcs ^= 0xffff;
238 val = fcs & 0xff;
239 MAKE_RAW_BYTE;
475be4d8 240 val = (fcs >> 8) & 0xff;
1da177e4
LT		 241 MAKE_RAW_BYTE;
242 val = HDLC_FLAG_VALUE;
475be4d8 243 for (j = 0; j < 8; j++) {
1da177e4
LT		 244 bitcnt++;
245 s_val >>= 1;
246 if (val & 1)
247 s_val |= 0x80;
248 else
249 s_val &= 0x7f;
475be4d8 250 if (bitcnt == 8) {
1da177e4
LT		 251 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
252 bitcnt = 0;
253 }
254 val >>= 1;
255 }
256 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 257 debugl1(bcs->cs, "tiger make_raw: in %u out %d.%d",
1da177e4
LT		 258 bcs->tx_skb->len, s_cnt, bitcnt);
259 if (bitcnt) {
475be4d8 260 while (8 > bitcnt++) {
1da177e4
LT		 261 s_val >>= 1;
262 s_val |= 0x80;
263 }
264 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
265 bcs->hw.tiger.sendbuf[s_cnt++] = 0xff; // NJ<->NJ thoughput bug fix
266 }
267 bcs->hw.tiger.sendcnt = s_cnt;
268 bcs->tx_cnt -= bcs->tx_skb->len;
269 bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
475be4d8 270 return (0);
1da177e4
LT		 271}
272
273// macro for 56k
274
475be4d8
JP		 275#define MAKE_RAW_BYTE_56K for (j = 0; j < 8; j++) { \
276 bitcnt++; \
277 s_val >>= 1; \
278 if (val & 1) { \
279 s_one++; \
280 s_val |= 0x80; \
281 } else { \
282 s_one = 0; \
283 s_val &= 0x7f; \
284 } \
285 if (bitcnt == 7) { \
286 s_val >>= 1; \
287 s_val |= 0x80; \
288 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
289 bitcnt = 0; \
290 } \
291 if (s_one == 5) { \
292 s_val >>= 1; \
293 s_val &= 0x7f; \
294 bitcnt++; \
295 s_one = 0; \
296 } \
297 if (bitcnt == 7) { \
298 s_val >>= 1; \
299 s_val |= 0x80; \
300 bcs->hw.tiger.sendbuf[s_cnt++] = s_val; \
301 bitcnt = 0; \
302 } \
303 val >>= 1; \
304 }
1da177e4
LT		 305
306static int make_raw_data_56k(struct BCState *bcs) {
307// this make_raw is for 56k
475be4d8 308 register u_int i, s_cnt = 0;
1da177e4
LT		 309 register u_char j;
310 register u_char val;
311 register u_char s_one = 0;
312 register u_char s_val = 0;
313 register u_char bitcnt = 0;
314 u_int fcs;
475be4d8 315
1da177e4
LT		 316 if (!bcs->tx_skb) {
317 debugl1(bcs->cs, "tiger make_raw_56k: NULL skb");
475be4d8 318 return (1);
1da177e4
LT		 319 }
320 val = HDLC_FLAG_VALUE;
475be4d8 321 for (j = 0; j < 8; j++) {
1da177e4
LT		 322 bitcnt++;
323 s_val >>= 1;
324 if (val & 1)
325 s_val |= 0x80;
326 else
327 s_val &= 0x7f;
475be4d8 328 if (bitcnt == 7) {
1da177e4
LT		 329 s_val >>= 1;
330 s_val |= 0x80;
331 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
332 bitcnt = 0;
333 }
334 val >>= 1;
335 };
336 fcs = PPP_INITFCS;
475be4d8 337 for (i = 0; i < bcs->tx_skb->len; i++) {
1da177e4 338 val = bcs->tx_skb->data[i];
475be4d8 339 fcs = PPP_FCS(fcs, val);
1da177e4
LT		 340 MAKE_RAW_BYTE_56K;
341 }
342 fcs ^= 0xffff;
343 val = fcs & 0xff;
344 MAKE_RAW_BYTE_56K;
475be4d8 345 val = (fcs >> 8) & 0xff;
1da177e4
LT		 346 MAKE_RAW_BYTE_56K;
347 val = HDLC_FLAG_VALUE;
475be4d8 348 for (j = 0; j < 8; j++) {
1da177e4
LT		 349 bitcnt++;
350 s_val >>= 1;
351 if (val & 1)
352 s_val |= 0x80;
353 else
354 s_val &= 0x7f;
475be4d8 355 if (bitcnt == 7) {
1da177e4
LT		 356 s_val >>= 1;
357 s_val |= 0x80;
358 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
359 bitcnt = 0;
360 }
361 val >>= 1;
362 }
363 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 364 debugl1(bcs->cs, "tiger make_raw_56k: in %u out %d.%d",
1da177e4
LT		 365 bcs->tx_skb->len, s_cnt, bitcnt);
366 if (bitcnt) {
475be4d8 367 while (8 > bitcnt++) {
1da177e4
LT		 368 s_val >>= 1;
369 s_val |= 0x80;
370 }
371 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
372 bcs->hw.tiger.sendbuf[s_cnt++] = 0xff; // NJ<->NJ thoughput bug fix
373 }
374 bcs->hw.tiger.sendcnt = s_cnt;
375 bcs->tx_cnt -= bcs->tx_skb->len;
376 bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
475be4d8 377 return (0);
1da177e4
LT		 378}
379
380static void got_frame(struct BCState *bcs, int count) {
381 struct sk_buff *skb;
475be4d8 382
1da177e4
LT		 383 if (!(skb = dev_alloc_skb(count)))
384 printk(KERN_WARNING "TIGER: receive out of memory\n");
385 else {
386 memcpy(skb_put(skb, count), bcs->hw.tiger.rcvbuf, count);
387 skb_queue_tail(&bcs->rqueue, skb);
388 }
389 test_and_set_bit(B_RCVBUFREADY, &bcs->event);
390 schedule_work(&bcs->tqueue);
475be4d8 391
1da177e4
LT		 392 if (bcs->cs->debug & L1_DEB_RECEIVE_FRAME)
393 printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, "rec");
394}
395
396
397
475be4d8 398static void read_raw(struct BCState *bcs, u_int *buf, int cnt) {
1da177e4
LT		 399 int i;
400 register u_char j;
401 register u_char val;
475be4d8 402 u_int *pend = bcs->hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
1da177e4
LT		 403 register u_char state = bcs->hw.tiger.r_state;
404 register u_char r_one = bcs->hw.tiger.r_one;
405 register u_char r_val = bcs->hw.tiger.r_val;
406 register u_int bitcnt = bcs->hw.tiger.r_bitcnt;
407 u_int *p = buf;
408 int bits;
409 u_char mask;
410
475be4d8 411 if (bcs->mode == L1_MODE_HDLC) { // it's 64k
1da177e4
LT		 412 mask = 0xff;
413 bits = 8;
414 }
415 else { // it's 56K
416 mask = 0x7f;
417 bits = 7;
418 };
475be4d8
JP		 419 for (i = 0; i < cnt; i++) {
420 val = bcs->channel ? ((*p >> 8) & 0xff) : (*p & 0xff);
1da177e4
LT		 421 p++;
422 if (p > pend)
423 p = bcs->hw.tiger.rec;
424 if ((val & mask) == mask) {
425 state = HDLC_ZERO_SEARCH;
426 bcs->hw.tiger.r_tot++;
427 bitcnt = 0;
428 r_one = 0;
429 continue;
430 }
475be4d8 431 for (j = 0; j < bits; j++) {
1da177e4
LT		 432 if (state == HDLC_ZERO_SEARCH) {
433 if (val & 1) {
434 r_one++;
435 } else {
475be4d8
JP		 436 r_one = 0;
437 state = HDLC_FLAG_SEARCH;
1da177e4 438 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8
JP		 439 debugl1(bcs->cs, "tiger read_raw: zBit(%d,%d,%d) %x",
440 bcs->hw.tiger.r_tot, i, j, val);
1da177e4 441 }
475be4d8 442 } else if (state == HDLC_FLAG_SEARCH) {
1da177e4
LT		 443 if (val & 1) {
444 r_one++;
475be4d8
JP		 445 if (r_one > 6) {
446 state = HDLC_ZERO_SEARCH;
1da177e4
LT		 447 }
448 } else {
475be4d8
JP		 449 if (r_one == 6) {
450 bitcnt = 0;
451 r_val = 0;
452 state = HDLC_FLAG_FOUND;
1da177e4 453 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8
JP		 454 debugl1(bcs->cs, "tiger read_raw: flag(%d,%d,%d) %x",
455 bcs->hw.tiger.r_tot, i, j, val);
1da177e4 456 }
475be4d8 457 r_one = 0;
1da177e4 458 }
475be4d8 459 } else if (state == HDLC_FLAG_FOUND) {
1da177e4
LT		 460 if (val & 1) {
461 r_one++;
475be4d8
JP		 462 if (r_one > 6) {
463 state = HDLC_ZERO_SEARCH;
1da177e4
LT		 464 } else {
465 r_val >>= 1;
466 r_val |= 0x80;
467 bitcnt++;
468 }
469 } else {
475be4d8
JP		 470 if (r_one == 6) {
471 bitcnt = 0;
472 r_val = 0;
473 r_one = 0;
1da177e4
LT		 474 val >>= 1;
475 continue;
475be4d8 476 } else if (r_one != 5) {
1da177e4
LT		 477 r_val >>= 1;
478 r_val &= 0x7f;
479 bitcnt++;
480 }
475be4d8 481 r_one = 0;
1da177e4
LT		 482 }
483 if ((state != HDLC_ZERO_SEARCH) &&
475be4d8
JP		 484 !(bitcnt & 7)) {
485 state = HDLC_FRAME_FOUND;
1da177e4
LT		 486 bcs->hw.tiger.r_fcs = PPP_INITFCS;
487 bcs->hw.tiger.rcvbuf[0] = r_val;
475be4d8 488 bcs->hw.tiger.r_fcs = PPP_FCS(bcs->hw.tiger.r_fcs, r_val);
1da177e4 489 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8
JP		 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,
1da177e4
LT		 492 bcs->cs->hw.njet.irqstat0);
493 }
494 } else if (state == HDLC_FRAME_FOUND) {
495 if (val & 1) {
496 r_one++;
475be4d8
JP		 497 if (r_one > 6) {
498 state = HDLC_ZERO_SEARCH;
499 bitcnt = 0;
1da177e4
LT		 500 } else {
501 r_val >>= 1;
502 r_val |= 0x80;
503 bitcnt++;
504 }
505 } else {
475be4d8
JP		 506 if (r_one == 6) {
507 r_val = 0;
508 r_one = 0;
1da177e4
LT		 509 bitcnt++;
510 if (bitcnt & 7) {
511 debugl1(bcs->cs, "tiger: frame not byte aligned");
475be4d8 512 state = HDLC_FLAG_SEARCH;
1da177e4
LT		 513 bcs->hw.tiger.r_err++;
514#ifdef ERROR_STATISTIC
515 bcs->err_inv++;
516#endif
517 } else {
518 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8
JP		 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);
1da177e4 521 if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) {
475be4d8 522 got_frame(bcs, (bitcnt >> 3) - 3);
1da177e4
LT		 523 } else {
524 if (bcs->cs->debug) {
525 debugl1(bcs->cs, "tiger FCS error");
526 printframe(bcs->cs, bcs->hw.tiger.rcvbuf,
475be4d8 527 (bitcnt >> 3) - 1, "rec");
1da177e4
LT		 528 bcs->hw.tiger.r_err++;
529 }
530#ifdef ERROR_STATISTIC
475be4d8 531 bcs->err_crc++;
1da177e4
LT		 532#endif
533 }
475be4d8 534 state = HDLC_FLAG_FOUND;
1da177e4 535 }
475be4d8
JP		 536 bitcnt = 0;
537 } else if (r_one == 5) {
1da177e4 538 val >>= 1;
475be4d8 539 r_one = 0;
1da177e4
LT		 540 continue;
541 } else {
542 r_val >>= 1;
543 r_val &= 0x7f;
544 bitcnt++;
545 }
475be4d8 546 r_one = 0;
1da177e4
LT		 547 }
548 if ((state == HDLC_FRAME_FOUND) &&
475be4d8
JP		 549 !(bitcnt & 7)) {
550 if ((bitcnt >> 3) >= HSCX_BUFMAX) {
1da177e4 551 debugl1(bcs->cs, "tiger: frame too big");
475be4d8
JP		 552 r_val = 0;
553 state = HDLC_FLAG_SEARCH;
1da177e4
LT		 554 bcs->hw.tiger.r_err++;
555#ifdef ERROR_STATISTIC
556 bcs->err_inv++;
557#endif
558 } else {
475be4d8
JP		 559 bcs->hw.tiger.rcvbuf[(bitcnt >> 3) - 1] = r_val;
560 bcs->hw.tiger.r_fcs =
561 PPP_FCS(bcs->hw.tiger.r_fcs, r_val);
1da177e4
LT		 562 }
563 }
564 }
565 val >>= 1;
566 }
567 bcs->hw.tiger.r_tot++;
568 }
569 bcs->hw.tiger.r_state = state;
570 bcs->hw.tiger.r_one = r_one;
571 bcs->hw.tiger.r_val = r_val;
572 bcs->hw.tiger.r_bitcnt = bitcnt;
573}
574
575void read_tiger(struct IsdnCardState *cs) {
576 u_int *p;
475be4d8
JP		 577 int cnt = NETJET_DMA_RXSIZE / 2;
578
1da177e4 579 if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) {
475be4d8 580 debugl1(cs, "tiger warn read double dma %x/%x",
1da177e4
LT		 581 cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
582#ifdef ERROR_STATISTIC
583 if (cs->bcs[0].mode)
584 cs->bcs[0].err_rdo++;
585 if (cs->bcs[1].mode)
586 cs->bcs[1].err_rdo++;
587#endif
588 return;
589 } else {
590 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ;
591 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ);
475be4d8 592 }
1da177e4
LT		 593 if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1)
594 p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
595 else
596 p = cs->bcs[0].hw.tiger.rec + cnt - 1;
597 if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
598 read_raw(cs->bcs, p, cnt);
599
600 if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
601 read_raw(cs->bcs + 1, p, cnt);
602 cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_READ;
603}
604
605static void write_raw(struct BCState *bcs, u_int *buf, int cnt);
606
607void netjet_fill_dma(struct BCState *bcs)
608{
609 register u_int *p, *sp;
610 register int cnt;
611
612 if (!bcs->tx_skb)
613 return;
614 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 615 debugl1(bcs->cs, "tiger fill_dma1: c%d %4lx", bcs->channel,
1da177e4
LT		 616 bcs->Flag);
617 if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag))
618 return;
619 if (bcs->mode == L1_MODE_HDLC) { // it's 64k
620 if (make_raw_data(bcs))
475be4d8 621 return;
1da177e4
LT		 622 }
623 else { // it's 56k
624 if (make_raw_data_56k(bcs))
475be4d8 625 return;
1da177e4
LT		 626 };
627 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 628 debugl1(bcs->cs, "tiger fill_dma2: c%d %4lx", bcs->channel,
1da177e4
LT		 629 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);
632 } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
633 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
634 sp = bcs->hw.tiger.sendp;
635 if (p == bcs->hw.tiger.s_end)
475be4d8 636 p = bcs->hw.tiger.send - 1;
1da177e4 637 if (sp == bcs->hw.tiger.s_end)
475be4d8 638 sp = bcs->hw.tiger.send - 1;
1da177e4 639 cnt = p - sp;
475be4d8 640 if (cnt < 0) {
1da177e4
LT		 641 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
642 } else {
643 p++;
644 cnt++;
645 if (p > bcs->hw.tiger.s_end)
646 p = bcs->hw.tiger.send;
647 p++;
648 cnt++;
649 if (p > bcs->hw.tiger.s_end)
650 p = bcs->hw.tiger.send;
651 write_raw(bcs, p, bcs->hw.tiger.free - cnt);
652 }
653 } else if (test_and_clear_bit(BC_FLG_EMPTY, &bcs->Flag)) {
654 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
655 cnt = bcs->hw.tiger.s_end - p;
656 if (cnt < 2) {
657 p = bcs->hw.tiger.send + 1;
475be4d8 658 cnt = NETJET_DMA_TXSIZE / 2 - 2;
1da177e4
LT		 659 } else {
660 p++;
661 p++;
475be4d8
JP		 662 if (cnt <= (NETJET_DMA_TXSIZE / 2))
663 cnt += NETJET_DMA_TXSIZE / 2;
1da177e4
LT		 664 cnt--;
665 cnt--;
666 }
667 write_raw(bcs, p, cnt);
668 }
669 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 670 debugl1(bcs->cs, "tiger fill_dma3: c%d %4lx", bcs->channel,
1da177e4
LT		 671 bcs->Flag);
672}
673
674static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
475be4d8 675 u_int mask, val, *p = buf;
1da177e4 676 u_int i, s_cnt;
475be4d8
JP		 677
678 if (cnt <= 0)
679 return;
1da177e4 680 if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
475be4d8 681 if (bcs->hw.tiger.sendcnt > cnt) {
1da177e4
LT		 682 s_cnt = cnt;
683 bcs->hw.tiger.sendcnt -= cnt;
684 } else {
685 s_cnt = bcs->hw.tiger.sendcnt;
686 bcs->hw.tiger.sendcnt = 0;
687 }
688 if (bcs->channel)
689 mask = 0xffff00ff;
690 else
691 mask = 0xffffff00;
475be4d8
JP		 692 for (i = 0; i < s_cnt; i++) {
693 val = bcs->channel ? ((bcs->hw.tiger.sp[i] << 8) & 0xff00) :
1da177e4 694 (bcs->hw.tiger.sp[i]);
475be4d8 695 *p &= mask;
1da177e4 696 *p++ |= val;
475be4d8 697 if (p > bcs->hw.tiger.s_end)
1da177e4
LT		 698 p = bcs->hw.tiger.send;
699 }
700 bcs->hw.tiger.s_tot += s_cnt;
701 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 702 debugl1(bcs->cs, "tiger write_raw: c%d %p-%p %d/%d %d %x", bcs->channel,
1da177e4
LT		 703 buf, p, s_cnt, cnt,
704 bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0);
705 if (bcs->cs->debug & L1_DEB_HSCX_FIFO)
706 printframe(bcs->cs, bcs->hw.tiger.sp, s_cnt, "snd");
707 bcs->hw.tiger.sp += s_cnt;
708 bcs->hw.tiger.sendp = p;
709 if (!bcs->hw.tiger.sendcnt) {
710 if (!bcs->tx_skb) {
475be4d8 711 debugl1(bcs->cs, "tiger write_raw: NULL skb s_cnt %d", s_cnt);
1da177e4 712 } else {
475be4d8
JP		 713 if (test_bit(FLG_LLI_L1WAKEUP, &bcs->st->lli.flag) &&
714 (PACKET_NOACK != bcs->tx_skb->pkt_type)) {
1da177e4
LT		 715 u_long flags;
716 spin_lock_irqsave(&bcs->aclock, flags);
717 bcs->ackcnt += bcs->tx_skb->len;
718 spin_unlock_irqrestore(&bcs->aclock, flags);
719 schedule_event(bcs, B_ACKPENDING);
720 }
721 dev_kfree_skb_any(bcs->tx_skb);
722 bcs->tx_skb = NULL;
723 }
724 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
725 bcs->hw.tiger.free = cnt - s_cnt;
475be4d8 726 if (bcs->hw.tiger.free > (NETJET_DMA_TXSIZE / 2))
1da177e4
LT		 727 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
728 else {
729 test_and_clear_bit(BC_FLG_HALF, &bcs->Flag);
730 test_and_set_bit(BC_FLG_NOFRAME, &bcs->Flag);
731 }
732 if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
733 netjet_fill_dma(bcs);
734 } else {
735 mask ^= 0xffffffff;
736 if (s_cnt < cnt) {
475be4d8 737 for (i = s_cnt; i < cnt; i++) {
1da177e4 738 *p++ |= mask;
475be4d8 739 if (p > bcs->hw.tiger.s_end)
1da177e4
LT		 740 p = bcs->hw.tiger.send;
741 }
742 if (bcs->cs->debug & L1_DEB_HSCX)
743 debugl1(bcs->cs, "tiger write_raw: fill rest %d",
744 cnt - s_cnt);
745 }
746 test_and_set_bit(B_XMTBUFREADY, &bcs->event);
747 schedule_work(&bcs->tqueue);
748 }
749 }
750 } else if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
751 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
752 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
753 bcs->hw.tiger.free += cnt;
754 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 755 debugl1(bcs->cs, "tiger write_raw: fill half");
1da177e4
LT		 756 } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
757 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
758 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
759 if (bcs->cs->debug & L1_DEB_HSCX)
475be4d8 760 debugl1(bcs->cs, "tiger write_raw: fill full");
1da177e4
LT		 761 }
762}
763
764void write_tiger(struct IsdnCardState *cs) {
475be4d8
JP		 765 u_int *p, cnt = NETJET_DMA_TXSIZE / 2;
766
1da177e4 767 if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) {
475be4d8 768 debugl1(cs, "tiger warn write double dma %x/%x",
1da177e4
LT		 769 cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
770#ifdef ERROR_STATISTIC
771 if (cs->bcs[0].mode)
772 cs->bcs[0].err_tx++;
773 if (cs->bcs[1].mode)
774 cs->bcs[1].err_tx++;
775#endif
776 return;
777 } else {
778 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE;
779 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE);
475be4d8 780 }
1da177e4
LT		 781 if (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE_1)
782 p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
783 else
784 p = cs->bcs[0].hw.tiger.send + cnt - 1;
785 if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
786 write_raw(cs->bcs, p, cnt);
787 if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
788 write_raw(cs->bcs + 1, p, cnt);
789 cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_WRITE;
790}
791
792static void
793tiger_l2l1(struct PStack *st, int pr, void *arg)
794{
795 struct BCState *bcs = st->l1.bcs;
796 struct sk_buff *skb = arg;
797 u_long flags;
798
799 switch (pr) {
475be4d8
JP		 800 case (PH_DATA | REQUEST):
801 spin_lock_irqsave(&bcs->cs->lock, flags);
802 if (bcs->tx_skb) {
803 skb_queue_tail(&bcs->squeue, skb);
804 } else {
805 bcs->tx_skb = skb;
806 bcs->cs->BC_Send_Data(bcs);
807 }
808 spin_unlock_irqrestore(&bcs->cs->lock, flags);
809 break;
810 case (PH_PULL | INDICATION):
811 spin_lock_irqsave(&bcs->cs->lock, flags);
812 if (bcs->tx_skb) {
813 printk(KERN_WARNING "tiger_l2l1: this shouldn't happen\n");
814 } else {
815 bcs->tx_skb = skb;
816 bcs->cs->BC_Send_Data(bcs);
817 }
818 spin_unlock_irqrestore(&bcs->cs->lock, flags);
819 break;
820 case (PH_PULL | REQUEST):
821 if (!bcs->tx_skb) {
822 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
823 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
824 } else
825 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
826 break;
827 case (PH_ACTIVATE | REQUEST):
828 spin_lock_irqsave(&bcs->cs->lock, flags);
829 test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
830 mode_tiger(bcs, st->l1.mode, st->l1.bc);
831 /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
832 spin_unlock_irqrestore(&bcs->cs->lock, flags);
833 bcs->cs->cardmsg(bcs->cs, MDL_BC_ASSIGN, (void *)(&st->l1.bc));
834 l1_msg_b(st, pr, arg);
835 break;
836 case (PH_DEACTIVATE | REQUEST):
837 /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
838 bcs->cs->cardmsg(bcs->cs, MDL_BC_RELEASE, (void *)(&st->l1.bc));
839 l1_msg_b(st, pr, arg);
840 break;
841 case (PH_DEACTIVATE | CONFIRM):
842 spin_lock_irqsave(&bcs->cs->lock, flags);
843 test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
844 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
845 mode_tiger(bcs, 0, st->l1.bc);
846 spin_unlock_irqrestore(&bcs->cs->lock, flags);
847 st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
848 break;
1da177e4
LT		 849 }
850}
851
852
672c3fd9 853static void
1da177e4
LT		 854close_tigerstate(struct BCState *bcs)
855{
856 mode_tiger(bcs, 0, bcs->channel);
857 if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
3c7208f2
JJ		 858 kfree(bcs->hw.tiger.rcvbuf);
859 bcs->hw.tiger.rcvbuf = NULL;
860 kfree(bcs->hw.tiger.sendbuf);
861 bcs->hw.tiger.sendbuf = NULL;
1da177e4
LT		 862 skb_queue_purge(&bcs->rqueue);
863 skb_queue_purge(&bcs->squeue);
864 if (bcs->tx_skb) {
865 dev_kfree_skb_any(bcs->tx_skb);
866 bcs->tx_skb = NULL;
867 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
868 }
869 }
870}
871
872static int
873open_tigerstate(struct IsdnCardState *cs, struct BCState *bcs)
874{
875 if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
876 if (!(bcs->hw.tiger.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
877 printk(KERN_WARNING
878 "HiSax: No memory for tiger.rcvbuf\n");
879 return (1);
880 }
881 if (!(bcs->hw.tiger.sendbuf = kmalloc(RAW_BUFMAX, GFP_ATOMIC))) {
882 printk(KERN_WARNING
883 "HiSax: No memory for tiger.sendbuf\n");
884 return (1);
885 }
886 skb_queue_head_init(&bcs->rqueue);
887 skb_queue_head_init(&bcs->squeue);
888 }
889 bcs->tx_skb = NULL;
890 bcs->hw.tiger.sendcnt = 0;
891 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
892 bcs->event = 0;
893 bcs->tx_cnt = 0;
894 return (0);
895}
896
672c3fd9 897static int
1da177e4
LT		 898setstack_tiger(struct PStack *st, struct BCState *bcs)
899{
900 bcs->channel = st->l1.bc;
901 if (open_tigerstate(st->l1.hardware, bcs))
902 return (-1);
903 st->l1.bcs = bcs;
904 st->l2.l2l1 = tiger_l2l1;
905 setstack_manager(st);
906 bcs->st = st;
907 setstack_l1_B(st);
908 return (0);
909}
910
475be4d8 911
67eb5db5 912void
1da177e4
LT		 913inittiger(struct IsdnCardState *cs)
914{
915 if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int),
475be4d8 916 GFP_KERNEL | GFP_DMA))) {
1da177e4
LT		 917 printk(KERN_WARNING
918 "HiSax: No memory for tiger.send\n");
919 return;
920 }
475be4d8 921 cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE / 2 - 1;
1da177e4
LT		 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;
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;
475be4d8 926
1da177e4
LT		 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,
929 cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1);
930 outl(virt_to_bus(cs->bcs[0].hw.tiger.send),
475be4d8 931 cs->hw.njet.base + NETJET_DMA_READ_START);
1da177e4 932 outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq),
475be4d8 933 cs->hw.njet.base + NETJET_DMA_READ_IRQ);
1da177e4 934 outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end),
475be4d8 935 cs->hw.njet.base + NETJET_DMA_READ_END);
1da177e4 936 if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int),
475be4d8 937 GFP_KERNEL | GFP_DMA))) {
1da177e4
LT		 938 printk(KERN_WARNING
939 "HiSax: No memory for tiger.rec\n");
940 return;
941 }
942 debugl1(cs, "tiger: rec buf %p - %p", cs->bcs[0].hw.tiger.rec,
943 cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1);
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));
946 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec),
475be4d8
JP		 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),
949 cs->hw.njet.base + NETJET_DMA_WRITE_IRQ);
1da177e4 950 outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1),
475be4d8 951 cs->hw.njet.base + NETJET_DMA_WRITE_END);
1da177e4
LT		 952 debugl1(cs, "tiger: dmacfg %x/%x pulse=%d",
953 inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
954 inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
955 bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
956 cs->hw.njet.last_is0 = 0;
957 cs->bcs[0].BC_SetStack = setstack_tiger;
958 cs->bcs[1].BC_SetStack = setstack_tiger;
959 cs->bcs[0].BC_Close = close_tigerstate;
960 cs->bcs[1].BC_Close = close_tigerstate;
961}
962
672c3fd9 963static void
1da177e4
LT		 964releasetiger(struct IsdnCardState *cs)
965{
3c7208f2
JJ		 966 kfree(cs->bcs[0].hw.tiger.send);
967 cs->bcs[0].hw.tiger.send = NULL;
968 cs->bcs[1].hw.tiger.send = NULL;
969 kfree(cs->bcs[0].hw.tiger.rec);
970 cs->bcs[0].hw.tiger.rec = NULL;
971 cs->bcs[1].hw.tiger.rec = NULL;
1da177e4
LT		 972}
973
974void
975release_io_netjet(struct IsdnCardState *cs)
976{
977 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
978 byteout(cs->hw.njet.base + NETJET_IRQMASK1, 0);
979 releasetiger(cs);
980 release_region(cs->hw.njet.base, 256);
981}