← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/isdn/hardware/avm/b1dma.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/isdn/hardware/avm/b1dma.c
 
1
/* $Id: b1dma.c,v 1.1.2.3 2004/02/10 01:07:12 keil Exp $
 
2
 * 
 
3
 * Common module for AVM B1 cards that support dma with AMCC
 
4
 * 
 
5
 * Copyright 2000 by Carsten Paeth <calle@calle.de>
 
6
 * 
 
7
 * This software may be used and distributed according to the terms
 
8
 * of the GNU General Public License, incorporated herein by reference.
 
9
 *
 
10
 */
 
11
 
 
12
#include <linux/module.h>
 
13
#include <linux/kernel.h>
 
14
#include <linux/proc_fs.h>
 
15
#include <linux/seq_file.h>
 
16
#include <linux/skbuff.h>
 
17
#include <linux/delay.h>
 
18
#include <linux/mm.h>
 
19
#include <linux/interrupt.h>
 
20
#include <linux/ioport.h>
 
21
#include <linux/capi.h>
 
22
#include <linux/kernelcapi.h>
 
23
#include <linux/gfp.h>
 
24
#include <asm/io.h>
 
25
#include <linux/init.h>
 
26
#include <asm/uaccess.h>
 
27
#include <linux/netdevice.h>
 
28
#include <linux/isdn/capilli.h>
 
29
#include "avmcard.h"
 
30
#include <linux/isdn/capicmd.h>
 
31
#include <linux/isdn/capiutil.h>
 
32
 
 
33
static char *revision = "$Revision: 1.1.2.3 $";
 
34
 
 
35
#undef AVM_B1DMA_DEBUG
 
36
 
 
37
/* ------------------------------------------------------------- */
 
38
 
 
39
MODULE_DESCRIPTION("CAPI4Linux: DMA support for active AVM cards");
 
40
MODULE_AUTHOR("Carsten Paeth");
 
41
MODULE_LICENSE("GPL");
 
42
 
 
43
static int suppress_pollack = 0;
 
44
module_param(suppress_pollack, bool, 0);
 
45
 
 
46
/* ------------------------------------------------------------- */
 
47
 
 
48
static void b1dma_dispatch_tx(avmcard *card);
 
49
 
 
50
/* ------------------------------------------------------------- */
 
51
 
 
52
/* S5933 */
 
53
 
 
54
#define AMCC_RXPTR      0x24
 
55
#define AMCC_RXLEN      0x28
 
56
#define AMCC_TXPTR      0x2c
 
57
#define AMCC_TXLEN      0x30
 
58
 
 
59
#define AMCC_INTCSR     0x38
 
60
#       define EN_READ_TC_INT           0x00008000L
 
61
#       define EN_WRITE_TC_INT          0x00004000L
 
62
#       define EN_TX_TC_INT             EN_READ_TC_INT
 
63
#       define EN_RX_TC_INT             EN_WRITE_TC_INT
 
64
#       define AVM_FLAG                 0x30000000L
 
65
 
 
66
#       define ANY_S5933_INT            0x00800000L
 
67
#       define READ_TC_INT              0x00080000L
 
68
#       define WRITE_TC_INT             0x00040000L
 
69
#       define  TX_TC_INT               READ_TC_INT
 
70
#       define  RX_TC_INT               WRITE_TC_INT
 
71
#       define MASTER_ABORT_INT         0x00100000L
 
72
#       define TARGET_ABORT_INT         0x00200000L
 
73
#       define BUS_MASTER_INT           0x00200000L
 
74
#       define ALL_INT                  0x000C0000L
 
75
 
 
76
#define AMCC_MCSR       0x3c
 
77
#       define A2P_HI_PRIORITY          0x00000100L
 
78
#       define EN_A2P_TRANSFERS         0x00000400L
 
79
#       define P2A_HI_PRIORITY          0x00001000L
 
80
#       define EN_P2A_TRANSFERS         0x00004000L
 
81
#       define RESET_A2P_FLAGS          0x04000000L
 
82
#       define RESET_P2A_FLAGS          0x02000000L
 
83
 
 
84
/* ------------------------------------------------------------- */
 
85
 
 
86
static inline void b1dma_writel(avmcard *card, u32 value, int off)
 
87
{
 
88
        writel(value, card->mbase + off);
 
89
}
 
90
 
 
91
static inline u32 b1dma_readl(avmcard *card, int off)
 
92
{
 
93
        return readl(card->mbase + off);
 
94
}
 
95
 
 
96
/* ------------------------------------------------------------- */
 
97
 
 
98
static inline int b1dma_tx_empty(unsigned int port)
 
99
{
 
100
        return inb(port + 0x03) & 0x1;
 
101
}
 
102
 
 
103
static inline int b1dma_rx_full(unsigned int port)
 
104
{
 
105
        return inb(port + 0x02) & 0x1;
 
106
}
 
107
 
 
108
static int b1dma_tolink(avmcard *card, void *buf, unsigned int len)
 
109
{
 
110
        unsigned long stop = jiffies + 1 * HZ;  /* maximum wait time 1 sec */
 
111
        unsigned char *s = (unsigned char *)buf;
 
112
        while (len--) {
 
113
                while (   !b1dma_tx_empty(card->port)
 
114
                       && time_before(jiffies, stop));
 
115
                if (!b1dma_tx_empty(card->port)) 
 
116
                        return -1;
 
117
                t1outp(card->port, 0x01, *s++);
 
118
        }
 
119
        return 0;
 
120
}
 
121
 
 
122
static int b1dma_fromlink(avmcard *card, void *buf, unsigned int len)
 
123
{
 
124
        unsigned long stop = jiffies + 1 * HZ;  /* maximum wait time 1 sec */
 
125
        unsigned char *s = (unsigned char *)buf;
 
126
        while (len--) {
 
127
                while (   !b1dma_rx_full(card->port)
 
128
                       && time_before(jiffies, stop));
 
129
                if (!b1dma_rx_full(card->port)) 
 
130
                        return -1;
 
131
                *s++ = t1inp(card->port, 0x00);
 
132
        }
 
133
        return 0;
 
134
}
 
135
 
 
136
static int WriteReg(avmcard *card, u32 reg, u8 val)
 
137
{
 
138
        u8 cmd = 0x00;
 
139
        if (   b1dma_tolink(card, &cmd, 1) == 0
 
140
            && b1dma_tolink(card, &reg, 4) == 0) {
 
141
                u32 tmp = val;
 
142
                return b1dma_tolink(card, &tmp, 4);
 
143
        }
 
144
        return -1;
 
145
}
 
146
 
 
147
static u8 ReadReg(avmcard *card, u32 reg)
 
148
{
 
149
        u8 cmd = 0x01;
 
150
        if (   b1dma_tolink(card, &cmd, 1) == 0
 
151
            && b1dma_tolink(card, &reg, 4) == 0) {
 
152
                u32 tmp;
 
153
                if (b1dma_fromlink(card, &tmp, 4) == 0)
 
154
                        return (u8)tmp;
 
155
        }
 
156
        return 0xff;
 
157
}
 
158
 
 
159
/* ------------------------------------------------------------- */
 
160
 
 
161
static inline void _put_byte(void **pp, u8 val)
 
162
{
 
163
        u8 *s = *pp;
 
164
        *s++ = val;
 
165
        *pp = s;
 
166
}
 
167
 
 
168
static inline void _put_word(void **pp, u32 val)
 
169
{
 
170
        u8 *s = *pp;
 
171
        *s++ = val & 0xff;
 
172
        *s++ = (val >> 8) & 0xff;
 
173
        *s++ = (val >> 16) & 0xff;
 
174
        *s++ = (val >> 24) & 0xff;
 
175
        *pp = s;
 
176
}
 
177
 
 
178
static inline void _put_slice(void **pp, unsigned char *dp, unsigned int len)
 
179
{
 
180
        unsigned i = len;
 
181
        _put_word(pp, i);
 
182
        while (i-- > 0)
 
183
                _put_byte(pp, *dp++);
 
184
}
 
185
 
 
186
static inline u8 _get_byte(void **pp)
 
187
{
 
188
        u8 *s = *pp;
 
189
        u8 val;
 
190
        val = *s++;
 
191
        *pp = s;
 
192
        return val;
 
193
}
 
194
 
 
195
static inline u32 _get_word(void **pp)
 
196
{
 
197
        u8 *s = *pp;
 
198
        u32 val;
 
199
        val = *s++;
 
200
        val |= (*s++ << 8);
 
201
        val |= (*s++ << 16);
 
202
        val |= (*s++ << 24);
 
203
        *pp = s;
 
204
        return val;
 
205
}
 
206
 
 
207
static inline u32 _get_slice(void **pp, unsigned char *dp)
 
208
{
 
209
        unsigned int len, i;
 
210
 
 
211
        len = i = _get_word(pp);
 
212
        while (i-- > 0) *dp++ = _get_byte(pp);
 
213
        return len;
 
214
}
 
215
 
 
216
/* ------------------------------------------------------------- */
 
217
 
 
218
void b1dma_reset(avmcard *card)
 
219
{
 
220
        card->csr = 0x0;
 
221
        b1dma_writel(card, card->csr, AMCC_INTCSR);
 
222
        b1dma_writel(card, 0, AMCC_MCSR);
 
223
        b1dma_writel(card, 0, AMCC_RXLEN);
 
224
        b1dma_writel(card, 0, AMCC_TXLEN);
 
225
 
 
226
        t1outp(card->port, 0x10, 0x00);
 
227
        t1outp(card->port, 0x07, 0x00);
 
228
 
 
229
        b1dma_writel(card, 0, AMCC_MCSR);
 
230
        mdelay(10);
 
231
        b1dma_writel(card, 0x0f000000, AMCC_MCSR); /* reset all */
 
232
        mdelay(10);
 
233
        b1dma_writel(card, 0, AMCC_MCSR);
 
234
        if (card->cardtype == avm_t1pci)
 
235
                mdelay(42);
 
236
        else
 
237
                mdelay(10);
 
238
}
 
239
 
 
240
/* ------------------------------------------------------------- */
 
241
 
 
242
static int b1dma_detect(avmcard *card)
 
243
{
 
244
        b1dma_writel(card, 0, AMCC_MCSR);
 
245
        mdelay(10);
 
246
        b1dma_writel(card, 0x0f000000, AMCC_MCSR); /* reset all */
 
247
        mdelay(10);
 
248
        b1dma_writel(card, 0, AMCC_MCSR);
 
249
        mdelay(42);
 
250
 
 
251
        b1dma_writel(card, 0, AMCC_RXLEN);
 
252
        b1dma_writel(card, 0, AMCC_TXLEN);
 
253
        card->csr = 0x0;
 
254
        b1dma_writel(card, card->csr, AMCC_INTCSR);
 
255
 
 
256
        if (b1dma_readl(card, AMCC_MCSR) != 0x000000E6)
 
257
                return 1;
 
258
 
 
259
        b1dma_writel(card, 0xffffffff, AMCC_RXPTR);
 
260
        b1dma_writel(card, 0xffffffff, AMCC_TXPTR);
 
261
        if (   b1dma_readl(card, AMCC_RXPTR) != 0xfffffffc
 
262
            || b1dma_readl(card, AMCC_TXPTR) != 0xfffffffc)
 
263
                return 2;
 
264
 
 
265
        b1dma_writel(card, 0x0, AMCC_RXPTR);
 
266
        b1dma_writel(card, 0x0, AMCC_TXPTR);
 
267
        if (   b1dma_readl(card, AMCC_RXPTR) != 0x0
 
268
            || b1dma_readl(card, AMCC_TXPTR) != 0x0)
 
269
                return 3;
 
270
 
 
271
        t1outp(card->port, 0x10, 0x00);
 
272
        t1outp(card->port, 0x07, 0x00);
 
273
        
 
274
        t1outp(card->port, 0x02, 0x02);
 
275
        t1outp(card->port, 0x03, 0x02);
 
276
 
 
277
        if (   (t1inp(card->port, 0x02) & 0xFE) != 0x02
 
278
            || t1inp(card->port, 0x3) != 0x03)
 
279
                return 4;
 
280
 
 
281
        t1outp(card->port, 0x02, 0x00);
 
282
        t1outp(card->port, 0x03, 0x00);
 
283
 
 
284
        if (   (t1inp(card->port, 0x02) & 0xFE) != 0x00
 
285
            || t1inp(card->port, 0x3) != 0x01)
 
286
                return 5;
 
287
 
 
288
        return 0;
 
289
}
 
290
 
 
291
int t1pci_detect(avmcard *card)
 
292
{
 
293
        int ret;
 
294
 
 
295
        if ((ret = b1dma_detect(card)) != 0)
 
296
                return ret;
 
297
        
 
298
        /* Transputer test */
 
299
        
 
300
        if (   WriteReg(card, 0x80001000, 0x11) != 0
 
301
            || WriteReg(card, 0x80101000, 0x22) != 0
 
302
            || WriteReg(card, 0x80201000, 0x33) != 0
 
303
            || WriteReg(card, 0x80301000, 0x44) != 0)
 
304
                return 6;
 
305
 
 
306
        if (   ReadReg(card, 0x80001000) != 0x11
 
307
            || ReadReg(card, 0x80101000) != 0x22
 
308
            || ReadReg(card, 0x80201000) != 0x33
 
309
            || ReadReg(card, 0x80301000) != 0x44)
 
310
                return 7;
 
311
 
 
312
        if (   WriteReg(card, 0x80001000, 0x55) != 0
 
313
            || WriteReg(card, 0x80101000, 0x66) != 0
 
314
            || WriteReg(card, 0x80201000, 0x77) != 0
 
315
            || WriteReg(card, 0x80301000, 0x88) != 0)
 
316
                return 8;
 
317
 
 
318
        if (   ReadReg(card, 0x80001000) != 0x55
 
319
            || ReadReg(card, 0x80101000) != 0x66
 
320
            || ReadReg(card, 0x80201000) != 0x77
 
321
            || ReadReg(card, 0x80301000) != 0x88)
 
322
                return 9;
 
323
 
 
324
        return 0;
 
325
}
 
326
 
 
327
int b1pciv4_detect(avmcard *card)
 
328
{
 
329
        int ret, i;
 
330
 
 
331
        if ((ret = b1dma_detect(card)) != 0)
 
332
                return ret;
 
333
        
 
334
        for (i=0; i < 5 ; i++) {
 
335
                if (WriteReg(card, 0x80A00000, 0x21) != 0)
 
336
                        return 6;
 
337
                if ((ReadReg(card, 0x80A00000) & 0x01) != 0x01)
 
338
                        return 7;
 
339
        }
 
340
        for (i=0; i < 5 ; i++) {
 
341
                if (WriteReg(card, 0x80A00000, 0x20) != 0)
 
342
                        return 8;
 
343
                if ((ReadReg(card, 0x80A00000) & 0x01) != 0x00)
 
344
                        return 9;
 
345
        }
 
346
        
 
347
        return 0;
 
348
}
 
349
 
 
350
static void b1dma_queue_tx(avmcard *card, struct sk_buff *skb)
 
351
{
 
352
        unsigned long flags;
 
353
 
 
354
        spin_lock_irqsave(&card->lock, flags);
 
355
 
 
356
        skb_queue_tail(&card->dma->send_queue, skb);
 
357
 
 
358
        if (!(card->csr & EN_TX_TC_INT)) {
 
359
                b1dma_dispatch_tx(card);
 
360
                b1dma_writel(card, card->csr, AMCC_INTCSR);
 
361
        }
 
362
 
 
363
        spin_unlock_irqrestore(&card->lock, flags);
 
364
}
 
365
 
 
366
/* ------------------------------------------------------------- */
 
367
 
 
368
static void b1dma_dispatch_tx(avmcard *card)
 
369
{
 
370
        avmcard_dmainfo *dma = card->dma;
 
371
        struct sk_buff *skb;
 
372
        u8 cmd, subcmd;
 
373
        u16 len;
 
374
        u32 txlen;
 
375
        void *p;
 
376
        
 
377
        skb = skb_dequeue(&dma->send_queue);
 
378
 
 
379
        len = CAPIMSG_LEN(skb->data);
 
380
 
 
381
        if (len) {
 
382
                cmd = CAPIMSG_COMMAND(skb->data);
 
383
                subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 
384
 
 
385
                p = dma->sendbuf.dmabuf;
 
386
 
 
387
                if (CAPICMD(cmd, subcmd) == CAPI_DATA_B3_REQ) {
 
388
                        u16 dlen = CAPIMSG_DATALEN(skb->data);
 
389
                        _put_byte(&p, SEND_DATA_B3_REQ);
 
390
                        _put_slice(&p, skb->data, len);
 
391
                        _put_slice(&p, skb->data + len, dlen);
 
392
                } else {
 
393
                        _put_byte(&p, SEND_MESSAGE);
 
394
                        _put_slice(&p, skb->data, len);
 
395
                }
 
396
                txlen = (u8 *)p - (u8 *)dma->sendbuf.dmabuf;
 
397
#ifdef AVM_B1DMA_DEBUG
 
398
                printk(KERN_DEBUG "tx: put msg len=%d\n", txlen);
 
399
#endif
 
400
        } else {
 
401
                txlen = skb->len-2;
 
402
#ifdef AVM_B1DMA_POLLDEBUG
 
403
                if (skb->data[2] == SEND_POLLACK)
 
404
                        printk(KERN_INFO "%s: send ack\n", card->name);
 
405
#endif
 
406
#ifdef AVM_B1DMA_DEBUG
 
407
                printk(KERN_DEBUG "tx: put 0x%x len=%d\n", 
 
408
                       skb->data[2], txlen);
 
409
#endif
 
410
                skb_copy_from_linear_data_offset(skb, 2, dma->sendbuf.dmabuf,
 
411
                                                 skb->len - 2);
 
412
        }
 
413
        txlen = (txlen + 3) & ~3;
 
414
 
 
415
        b1dma_writel(card, dma->sendbuf.dmaaddr, AMCC_TXPTR);
 
416
        b1dma_writel(card, txlen, AMCC_TXLEN);
 
417
 
 
418
        card->csr |= EN_TX_TC_INT;
 
419
 
 
420
        dev_kfree_skb_any(skb);
 
421
}
 
422
 
 
423
/* ------------------------------------------------------------- */
 
424
 
 
425
static void queue_pollack(avmcard *card)
 
426
{
 
427
        struct sk_buff *skb;
 
428
        void *p;
 
429
 
 
430
        skb = alloc_skb(3, GFP_ATOMIC);
 
431
        if (!skb) {
 
432
                printk(KERN_CRIT "%s: no memory, lost poll ack\n",
 
433
                                        card->name);
 
434
                return;
 
435
        }
 
436
        p = skb->data;
 
437
        _put_byte(&p, 0);
 
438
        _put_byte(&p, 0);
 
439
        _put_byte(&p, SEND_POLLACK);
 
440
        skb_put(skb, (u8 *)p - (u8 *)skb->data);
 
441
 
 
442
        b1dma_queue_tx(card, skb);
 
443
}
 
444
 
 
445
/* ------------------------------------------------------------- */
 
446
 
 
447
static void b1dma_handle_rx(avmcard *card)
 
448
{
 
449
        avmctrl_info *cinfo = &card->ctrlinfo[0];
 
450
        avmcard_dmainfo *dma = card->dma;
 
451
        struct capi_ctr *ctrl = &cinfo->capi_ctrl;
 
452
        struct sk_buff *skb;
 
453
        void *p = dma->recvbuf.dmabuf+4;
 
454
        u32 ApplId, MsgLen, DataB3Len, NCCI, WindowSize;
 
455
        u8 b1cmd =  _get_byte(&p);
 
456
 
 
457
#ifdef AVM_B1DMA_DEBUG
 
458
        printk(KERN_DEBUG "rx: 0x%x %lu\n", b1cmd, (unsigned long)dma->recvlen);
 
459
#endif
 
460
        
 
461
        switch (b1cmd) {
 
462
        case RECEIVE_DATA_B3_IND:
 
463
 
 
464
                ApplId = (unsigned) _get_word(&p);
 
465
                MsgLen = _get_slice(&p, card->msgbuf);
 
466
                DataB3Len = _get_slice(&p, card->databuf);
 
467
 
 
468
                if (MsgLen < 30) { /* not CAPI 64Bit */
 
469
                        memset(card->msgbuf+MsgLen, 0, 30-MsgLen);
 
470
                        MsgLen = 30;
 
471
                        CAPIMSG_SETLEN(card->msgbuf, 30);
 
472
                }
 
473
                if (!(skb = alloc_skb(DataB3Len+MsgLen, GFP_ATOMIC))) {
 
474
                        printk(KERN_ERR "%s: incoming packet dropped\n",
 
475
                                        card->name);
 
476
                } else {
 
477
                        memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
 
478
                        memcpy(skb_put(skb, DataB3Len), card->databuf, DataB3Len);
 
479
                        capi_ctr_handle_message(ctrl, ApplId, skb);
 
480
                }
 
481
                break;
 
482
 
 
483
        case RECEIVE_MESSAGE:
 
484
 
 
485
                ApplId = (unsigned) _get_word(&p);
 
486
                MsgLen = _get_slice(&p, card->msgbuf);
 
487
                if (!(skb = alloc_skb(MsgLen, GFP_ATOMIC))) {
 
488
                        printk(KERN_ERR "%s: incoming packet dropped\n",
 
489
                                        card->name);
 
490
                } else {
 
491
                        memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
 
492
                        if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_CONF) {
 
493
                                spin_lock(&card->lock);
 
494
                                capilib_data_b3_conf(&cinfo->ncci_head, ApplId,
 
495
                                        CAPIMSG_NCCI(skb->data),
 
496
                                        CAPIMSG_MSGID(skb->data));
 
497
                                spin_unlock(&card->lock);
 
498
                        }
 
499
                        capi_ctr_handle_message(ctrl, ApplId, skb);
 
500
                }
 
501
                break;
 
502
 
 
503
        case RECEIVE_NEW_NCCI:
 
504
 
 
505
                ApplId = _get_word(&p);
 
506
                NCCI = _get_word(&p);
 
507
                WindowSize = _get_word(&p);
 
508
                spin_lock(&card->lock);
 
509
                capilib_new_ncci(&cinfo->ncci_head, ApplId, NCCI, WindowSize);
 
510
                spin_unlock(&card->lock);
 
511
                break;
 
512
 
 
513
        case RECEIVE_FREE_NCCI:
 
514
 
 
515
                ApplId = _get_word(&p);
 
516
                NCCI = _get_word(&p);
 
517
 
 
518
                if (NCCI != 0xffffffff) {
 
519
                        spin_lock(&card->lock);
 
520
                        capilib_free_ncci(&cinfo->ncci_head, ApplId, NCCI);
 
521
                        spin_unlock(&card->lock);
 
522
                }
 
523
                break;
 
524
 
 
525
        case RECEIVE_START:
 
526
#ifdef AVM_B1DMA_POLLDEBUG
 
527
                printk(KERN_INFO "%s: receive poll\n", card->name);
 
528
#endif
 
529
                if (!suppress_pollack)
 
530
                        queue_pollack(card);
 
531
                capi_ctr_resume_output(ctrl);
 
532
                break;
 
533
 
 
534
        case RECEIVE_STOP:
 
535
                capi_ctr_suspend_output(ctrl);
 
536
                break;
 
537
 
 
538
        case RECEIVE_INIT:
 
539
 
 
540
                cinfo->versionlen = _get_slice(&p, cinfo->versionbuf);
 
541
                b1_parse_version(cinfo);
 
542
                printk(KERN_INFO "%s: %s-card (%s) now active\n",
 
543
                       card->name,
 
544
                       cinfo->version[VER_CARDTYPE],
 
545
                       cinfo->version[VER_DRIVER]);
 
546
                capi_ctr_ready(ctrl);
 
547
                break;
 
548
 
 
549
        case RECEIVE_TASK_READY:
 
550
                ApplId = (unsigned) _get_word(&p);
 
551
                MsgLen = _get_slice(&p, card->msgbuf);
 
552
                card->msgbuf[MsgLen] = 0;
 
553
                while (    MsgLen > 0
 
554
                       && (   card->msgbuf[MsgLen-1] == '\n'
 
555
                           || card->msgbuf[MsgLen-1] == '\r')) {
 
556
                        card->msgbuf[MsgLen-1] = 0;
 
557
                        MsgLen--;
 
558
                }
 
559
                printk(KERN_INFO "%s: task %d \"%s\" ready.\n",
 
560
                                card->name, ApplId, card->msgbuf);
 
561
                break;
 
562
 
 
563
        case RECEIVE_DEBUGMSG:
 
564
                MsgLen = _get_slice(&p, card->msgbuf);
 
565
                card->msgbuf[MsgLen] = 0;
 
566
                while (    MsgLen > 0
 
567
                       && (   card->msgbuf[MsgLen-1] == '\n'
 
568
                           || card->msgbuf[MsgLen-1] == '\r')) {
 
569
                        card->msgbuf[MsgLen-1] = 0;
 
570
                        MsgLen--;
 
571
                }
 
572
                printk(KERN_INFO "%s: DEBUG: %s\n", card->name, card->msgbuf);
 
573
                break;
 
574
 
 
575
        default:
 
576
                printk(KERN_ERR "%s: b1dma_interrupt: 0x%x ???\n",
 
577
                                card->name, b1cmd);
 
578
                return;
 
579
        }
 
580
}
 
581
 
 
582
/* ------------------------------------------------------------- */
 
583
 
 
584
static void b1dma_handle_interrupt(avmcard *card)
 
585
{
 
586
        u32 status;
 
587
        u32 newcsr;
 
588
 
 
589
        spin_lock(&card->lock);
 
590
 
 
591
        status = b1dma_readl(card, AMCC_INTCSR);
 
592
        if ((status & ANY_S5933_INT) == 0) {
 
593
                spin_unlock(&card->lock);
 
594
                return;
 
595
        }
 
596
 
 
597
        newcsr = card->csr | (status & ALL_INT);
 
598
        if (status & TX_TC_INT) newcsr &= ~EN_TX_TC_INT;
 
599
        if (status & RX_TC_INT) newcsr &= ~EN_RX_TC_INT;
 
600
        b1dma_writel(card, newcsr, AMCC_INTCSR);
 
601
 
 
602
        if ((status & RX_TC_INT) != 0) {
 
603
                struct avmcard_dmainfo *dma = card->dma;
 
604
                u32 rxlen;
 
605
                if (card->dma->recvlen == 0) {
 
606
                        rxlen = b1dma_readl(card, AMCC_RXLEN);
 
607
                        if (rxlen == 0) {
 
608
                                dma->recvlen = *((u32 *)dma->recvbuf.dmabuf);
 
609
                                rxlen = (dma->recvlen + 3) & ~3;
 
610
                                b1dma_writel(card, dma->recvbuf.dmaaddr+4, AMCC_RXPTR);
 
611
                                b1dma_writel(card, rxlen, AMCC_RXLEN);
 
612
#ifdef AVM_B1DMA_DEBUG
 
613
                        } else {
 
614
                                printk(KERN_ERR "%s: rx not complete (%d).\n",
 
615
                                        card->name, rxlen);
 
616
#endif
 
617
                        }
 
618
                } else {
 
619
                        spin_unlock(&card->lock);
 
620
                        b1dma_handle_rx(card);
 
621
                        dma->recvlen = 0;
 
622
                        spin_lock(&card->lock);
 
623
                        b1dma_writel(card, dma->recvbuf.dmaaddr, AMCC_RXPTR);
 
624
                        b1dma_writel(card, 4, AMCC_RXLEN);
 
625
                }
 
626
        }
 
627
 
 
628
        if ((status & TX_TC_INT) != 0) {
 
629
                if (skb_queue_empty(&card->dma->send_queue))
 
630
                        card->csr &= ~EN_TX_TC_INT;
 
631
                else
 
632
                        b1dma_dispatch_tx(card);
 
633
        }
 
634
        b1dma_writel(card, card->csr, AMCC_INTCSR);
 
635
 
 
636
        spin_unlock(&card->lock);
 
637
}
 
638
 
 
639
irqreturn_t b1dma_interrupt(int interrupt, void *devptr)
 
640
{
 
641
        avmcard *card = devptr;
 
642
 
 
643
        b1dma_handle_interrupt(card);
 
644
        return IRQ_HANDLED;
 
645
}
 
646
 
 
647
/* ------------------------------------------------------------- */
 
648
 
 
649
static int b1dma_loaded(avmcard *card)
 
650
{
 
651
        unsigned long stop;
 
652
        unsigned char ans;
 
653
        unsigned long tout = 2;
 
654
        unsigned int base = card->port;
 
655
 
 
656
        for (stop = jiffies + tout * HZ; time_before(jiffies, stop);) {
 
657
                if (b1_tx_empty(base))
 
658
                        break;
 
659
        }
 
660
        if (!b1_tx_empty(base)) {
 
661
                printk(KERN_ERR "%s: b1dma_loaded: tx err, corrupted t4 file ?\n",
 
662
                                card->name);
 
663
                return 0;
 
664
        }
 
665
        b1_put_byte(base, SEND_POLLACK);
 
666
        for (stop = jiffies + tout * HZ; time_before(jiffies, stop);) {
 
667
                if (b1_rx_full(base)) {
 
668
                        if ((ans = b1_get_byte(base)) == RECEIVE_POLLDWORD) {
 
669
                                return 1;
 
670
                        }
 
671
                        printk(KERN_ERR "%s: b1dma_loaded: got 0x%x, firmware not running in dword mode\n", card->name, ans);
 
672
                        return 0;
 
673
                }
 
674
        }
 
675
        printk(KERN_ERR "%s: b1dma_loaded: firmware not running\n", card->name);
 
676
        return 0;
 
677
}
 
678
 
 
679
/* ------------------------------------------------------------- */
 
680
 
 
681
static void b1dma_send_init(avmcard *card)
 
682
{
 
683
        struct sk_buff *skb;
 
684
        void *p;
 
685
 
 
686
        skb = alloc_skb(15, GFP_ATOMIC);
 
687
        if (!skb) {
 
688
                printk(KERN_CRIT "%s: no memory, lost register appl.\n",
 
689
                                        card->name);
 
690
                return;
 
691
        }
 
692
        p = skb->data;
 
693
        _put_byte(&p, 0);
 
694
        _put_byte(&p, 0);
 
695
        _put_byte(&p, SEND_INIT);
 
696
        _put_word(&p, CAPI_MAXAPPL);
 
697
        _put_word(&p, AVM_NCCI_PER_CHANNEL*30);
 
698
        _put_word(&p, card->cardnr - 1);
 
699
        skb_put(skb, (u8 *)p - (u8 *)skb->data);
 
700
 
 
701
        b1dma_queue_tx(card, skb);
 
702
}
 
703
 
 
704
int b1dma_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
 
705
{
 
706
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 
707
        avmcard *card = cinfo->card;
 
708
        int retval;
 
709
 
 
710
        b1dma_reset(card);
 
711
 
 
712
        if ((retval = b1_load_t4file(card, &data->firmware))) {
 
713
                b1dma_reset(card);
 
714
                printk(KERN_ERR "%s: failed to load t4file!!\n",
 
715
                                        card->name);
 
716
                return retval;
 
717
        }
 
718
 
 
719
        if (data->configuration.len > 0 && data->configuration.data) {
 
720
                if ((retval = b1_load_config(card, &data->configuration))) {
 
721
                        b1dma_reset(card);
 
722
                        printk(KERN_ERR "%s: failed to load config!!\n",
 
723
                                        card->name);
 
724
                        return retval;
 
725
                }
 
726
        }
 
727
 
 
728
        if (!b1dma_loaded(card)) {
 
729
                b1dma_reset(card);
 
730
                printk(KERN_ERR "%s: failed to load t4file.\n", card->name);
 
731
                return -EIO;
 
732
        }
 
733
 
 
734
        card->csr = AVM_FLAG;
 
735
        b1dma_writel(card, card->csr, AMCC_INTCSR);
 
736
        b1dma_writel(card, EN_A2P_TRANSFERS|EN_P2A_TRANSFERS|A2P_HI_PRIORITY|
 
737
                     P2A_HI_PRIORITY|RESET_A2P_FLAGS|RESET_P2A_FLAGS, 
 
738
                     AMCC_MCSR);
 
739
        t1outp(card->port, 0x07, 0x30);
 
740
        t1outp(card->port, 0x10, 0xF0);
 
741
 
 
742
        card->dma->recvlen = 0;
 
743
        b1dma_writel(card, card->dma->recvbuf.dmaaddr, AMCC_RXPTR);
 
744
        b1dma_writel(card, 4, AMCC_RXLEN);
 
745
        card->csr |= EN_RX_TC_INT;
 
746
        b1dma_writel(card, card->csr, AMCC_INTCSR);
 
747
 
 
748
        b1dma_send_init(card);
 
749
 
 
750
        return 0;
 
751
}
 
752
 
 
753
void b1dma_reset_ctr(struct capi_ctr *ctrl)
 
754
{
 
755
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 
756
        avmcard *card = cinfo->card;
 
757
        unsigned long flags;
 
758
 
 
759
        spin_lock_irqsave(&card->lock, flags);
 
760
        b1dma_reset(card);
 
761
 
 
762
        memset(cinfo->version, 0, sizeof(cinfo->version));
 
763
        capilib_release(&cinfo->ncci_head);
 
764
        spin_unlock_irqrestore(&card->lock, flags);
 
765
        capi_ctr_down(ctrl);
 
766
}
 
767
 
 
768
/* ------------------------------------------------------------- */
 
769
 
 
770
void b1dma_register_appl(struct capi_ctr *ctrl,
 
771
                                u16 appl,
 
772
                                capi_register_params *rp)
 
773
{
 
774
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 
775
        avmcard *card = cinfo->card;
 
776
        struct sk_buff *skb;
 
777
        int want = rp->level3cnt;
 
778
        int nconn;
 
779
        void *p;
 
780
 
 
781
        if (want > 0) nconn = want;
 
782
        else nconn = ctrl->profile.nbchannel * -want;
 
783
        if (nconn == 0) nconn = ctrl->profile.nbchannel;
 
784
 
 
785
        skb = alloc_skb(23, GFP_ATOMIC);
 
786
        if (!skb) {
 
787
                printk(KERN_CRIT "%s: no memory, lost register appl.\n",
 
788
                                        card->name);
 
789
                return;
 
790
        }
 
791
        p = skb->data;
 
792
        _put_byte(&p, 0);
 
793
        _put_byte(&p, 0);
 
794
        _put_byte(&p, SEND_REGISTER);
 
795
        _put_word(&p, appl);
 
796
        _put_word(&p, 1024 * (nconn+1));
 
797
        _put_word(&p, nconn);
 
798
        _put_word(&p, rp->datablkcnt);
 
799
        _put_word(&p, rp->datablklen);
 
800
        skb_put(skb, (u8 *)p - (u8 *)skb->data);
 
801
 
 
802
        b1dma_queue_tx(card, skb);
 
803
}
 
804
 
 
805
/* ------------------------------------------------------------- */
 
806
 
 
807
void b1dma_release_appl(struct capi_ctr *ctrl, u16 appl)
 
808
{
 
809
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 
810
        avmcard *card = cinfo->card;
 
811
        struct sk_buff *skb;
 
812
        void *p;
 
813
        unsigned long flags;
 
814
 
 
815
        spin_lock_irqsave(&card->lock, flags);
 
816
        capilib_release_appl(&cinfo->ncci_head, appl);
 
817
        spin_unlock_irqrestore(&card->lock, flags);
 
818
 
 
819
        skb = alloc_skb(7, GFP_ATOMIC);
 
820
        if (!skb) {
 
821
                printk(KERN_CRIT "%s: no memory, lost release appl.\n",
 
822
                                        card->name);
 
823
                return;
 
824
        }
 
825
        p = skb->data;
 
826
        _put_byte(&p, 0);
 
827
        _put_byte(&p, 0);
 
828
        _put_byte(&p, SEND_RELEASE);
 
829
        _put_word(&p, appl);
 
830
 
 
831
        skb_put(skb, (u8 *)p - (u8 *)skb->data);
 
832
 
 
833
        b1dma_queue_tx(card, skb);
 
834
}
 
835
 
 
836
/* ------------------------------------------------------------- */
 
837
 
 
838
u16 b1dma_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
 
839
{
 
840
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 
841
        avmcard *card = cinfo->card;
 
842
        u16 retval = CAPI_NOERROR;
 
843
 
 
844
        if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_REQ) {
 
845
                unsigned long flags;
 
846
                spin_lock_irqsave(&card->lock, flags);
 
847
                retval = capilib_data_b3_req(&cinfo->ncci_head,
 
848
                                             CAPIMSG_APPID(skb->data),
 
849
                                             CAPIMSG_NCCI(skb->data),
 
850
                                             CAPIMSG_MSGID(skb->data));
 
851
                spin_unlock_irqrestore(&card->lock, flags);
 
852
        }
 
853
        if (retval == CAPI_NOERROR) 
 
854
                b1dma_queue_tx(card, skb);
 
855
 
 
856
        return retval;
 
857
}
 
858
 
 
859
/* ------------------------------------------------------------- */
 
860
 
 
861
static int b1dmactl_proc_show(struct seq_file *m, void *v)
 
862
{
 
863
        struct capi_ctr *ctrl = m->private;
 
864
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 
865
        avmcard *card = cinfo->card;
 
866
        u8 flag;
 
867
        char *s;
 
868
        u32 txoff, txlen, rxoff, rxlen, csr;
 
869
        unsigned long flags;
 
870
 
 
871
        seq_printf(m, "%-16s %s\n", "name", card->name);
 
872
        seq_printf(m, "%-16s 0x%x\n", "io", card->port);
 
873
        seq_printf(m, "%-16s %d\n", "irq", card->irq);
 
874
        seq_printf(m, "%-16s 0x%lx\n", "membase", card->membase);
 
875
        switch (card->cardtype) {
 
876
        case avm_b1isa: s = "B1 ISA"; break;
 
877
        case avm_b1pci: s = "B1 PCI"; break;
 
878
        case avm_b1pcmcia: s = "B1 PCMCIA"; break;
 
879
        case avm_m1: s = "M1"; break;
 
880
        case avm_m2: s = "M2"; break;
 
881
        case avm_t1isa: s = "T1 ISA (HEMA)"; break;
 
882
        case avm_t1pci: s = "T1 PCI"; break;
 
883
        case avm_c4: s = "C4"; break;
 
884
        case avm_c2: s = "C2"; break;
 
885
        default: s = "???"; break;
 
886
        }
 
887
        seq_printf(m, "%-16s %s\n", "type", s);
 
888
        if ((s = cinfo->version[VER_DRIVER]) != NULL)
 
889
                seq_printf(m, "%-16s %s\n", "ver_driver", s);
 
890
        if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
 
891
                seq_printf(m, "%-16s %s\n", "ver_cardtype", s);
 
892
        if ((s = cinfo->version[VER_SERIAL]) != NULL)
 
893
                seq_printf(m, "%-16s %s\n", "ver_serial", s);
 
894
 
 
895
        if (card->cardtype != avm_m1) {
 
896
                flag = ((u8 *)(ctrl->profile.manu))[3];
 
897
                if (flag)
 
898
                        seq_printf(m, "%-16s%s%s%s%s%s%s%s\n",
 
899
                        "protocol",
 
900
                        (flag & 0x01) ? " DSS1" : "",
 
901
                        (flag & 0x02) ? " CT1" : "",
 
902
                        (flag & 0x04) ? " VN3" : "",
 
903
                        (flag & 0x08) ? " NI1" : "",
 
904
                        (flag & 0x10) ? " AUSTEL" : "",
 
905
                        (flag & 0x20) ? " ESS" : "",
 
906
                        (flag & 0x40) ? " 1TR6" : ""
 
907
                        );
 
908
        }
 
909
        if (card->cardtype != avm_m1) {
 
910
                flag = ((u8 *)(ctrl->profile.manu))[5];
 
911
                if (flag)
 
912
                        seq_printf(m, "%-16s%s%s%s%s\n",
 
913
                        "linetype",
 
914
                        (flag & 0x01) ? " point to point" : "",
 
915
                        (flag & 0x02) ? " point to multipoint" : "",
 
916
                        (flag & 0x08) ? " leased line without D-channel" : "",
 
917
                        (flag & 0x04) ? " leased line with D-channel" : ""
 
918
                        );
 
919
        }
 
920
        seq_printf(m, "%-16s %s\n", "cardname", cinfo->cardname);
 
921
 
 
922
 
 
923
        spin_lock_irqsave(&card->lock, flags);
 
924
 
 
925
        txoff = (dma_addr_t)b1dma_readl(card, AMCC_TXPTR)-card->dma->sendbuf.dmaaddr;
 
926
        txlen = b1dma_readl(card, AMCC_TXLEN);
 
927
 
 
928
        rxoff = (dma_addr_t)b1dma_readl(card, AMCC_RXPTR)-card->dma->recvbuf.dmaaddr;
 
929
        rxlen = b1dma_readl(card, AMCC_RXLEN);
 
930
 
 
931
        csr  = b1dma_readl(card, AMCC_INTCSR);
 
932
 
 
933
        spin_unlock_irqrestore(&card->lock, flags);
 
934
 
 
935
        seq_printf(m, "%-16s 0x%lx\n", "csr (cached)", (unsigned long)card->csr);
 
936
        seq_printf(m, "%-16s 0x%lx\n", "csr", (unsigned long)csr);
 
937
        seq_printf(m, "%-16s %lu\n", "txoff", (unsigned long)txoff);
 
938
        seq_printf(m, "%-16s %lu\n", "txlen", (unsigned long)txlen);
 
939
        seq_printf(m, "%-16s %lu\n", "rxoff", (unsigned long)rxoff);
 
940
        seq_printf(m, "%-16s %lu\n", "rxlen", (unsigned long)rxlen);
 
941
 
 
942
        return 0;
 
943
}
 
944
 
 
945
static int b1dmactl_proc_open(struct inode *inode, struct file *file)
 
946
{
 
947
        return single_open(file, b1dmactl_proc_show, PDE(inode)->data);
 
948
}
 
949
 
 
950
const struct file_operations b1dmactl_proc_fops = {
 
951
        .owner          = THIS_MODULE,
 
952
        .open           = b1dmactl_proc_open,
 
953
        .read           = seq_read,
 
954
        .llseek         = seq_lseek,
 
955
        .release        = single_release,
 
956
};
 
957
EXPORT_SYMBOL(b1dmactl_proc_fops);
 
958
 
 
959
/* ------------------------------------------------------------- */
 
960
 
 
961
EXPORT_SYMBOL(b1dma_reset);
 
962
EXPORT_SYMBOL(t1pci_detect);
 
963
EXPORT_SYMBOL(b1pciv4_detect);
 
964
EXPORT_SYMBOL(b1dma_interrupt);
 
965
 
 
966
EXPORT_SYMBOL(b1dma_load_firmware);
 
967
EXPORT_SYMBOL(b1dma_reset_ctr);
 
968
EXPORT_SYMBOL(b1dma_register_appl);
 
969
EXPORT_SYMBOL(b1dma_release_appl);
 
970
EXPORT_SYMBOL(b1dma_send_message);
 
971
 
 
972
static int __init b1dma_init(void)
 
973
{
 
974
        char *p;
 
975
        char rev[32];
 
976
 
 
977
        if ((p = strchr(revision, ':')) != NULL && p[1]) {
 
978
                strlcpy(rev, p + 2, sizeof(rev));
 
979
                if ((p = strchr(rev, '$')) != NULL && p > rev)
 
980
                   *(p-1) = 0;
 
981
        } else
 
982
                strcpy(rev, "1.0");
 
983
 
 
984
        printk(KERN_INFO "b1dma: revision %s\n", rev);
 
985
 
 
986
        return 0;
 
987
}
 
988
 
 
989
static void __exit b1dma_exit(void)
 
990
{
 
991
}
 
992
 
 
993
module_init(b1dma_init);
 
994
module_exit(b1dma_exit);