OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [atm/] [zatm.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/* drivers/atm/zatm.c - ZeitNet ZN122x device driver */
2
 
3
/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
4
 
5
 
6
#include <linux/module.h>
7
#include <linux/kernel.h>
8
#include <linux/mm.h>
9
#include <linux/pci.h>
10
#include <linux/errno.h>
11
#include <linux/atm.h>
12
#include <linux/atmdev.h>
13
#include <linux/sonet.h>
14
#include <linux/skbuff.h>
15
#include <linux/netdevice.h>
16
#include <linux/delay.h>
17
#include <linux/uio.h>
18
#include <linux/init.h>
19
#include <linux/dma-mapping.h>
20
#include <linux/atm_zatm.h>
21
#include <linux/capability.h>
22
#include <linux/bitops.h>
23
#include <linux/wait.h>
24
#include <asm/byteorder.h>
25
#include <asm/system.h>
26
#include <asm/string.h>
27
#include <asm/io.h>
28
#include <asm/atomic.h>
29
#include <asm/uaccess.h>
30
 
31
#include "uPD98401.h"
32
#include "uPD98402.h"
33
#include "zeprom.h"
34
#include "zatm.h"
35
 
36
 
37
/*
38
 * TODO:
39
 *
40
 * Minor features
41
 *  - support 64 kB SDUs (will have to use multibuffer batches then :-( )
42
 *  - proper use of CDV, credit = max(1,CDVT*PCR)
43
 *  - AAL0
44
 *  - better receive timestamps
45
 *  - OAM
46
 */
47
 
48
#define ZATM_COPPER     1
49
 
50
#if 0
51
#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
52
#else
53
#define DPRINTK(format,args...)
54
#endif
55
 
56
#ifndef CONFIG_ATM_ZATM_DEBUG
57
 
58
 
59
#define NULLCHECK(x)
60
 
61
#define EVENT(s,a,b)
62
 
63
 
64
static void event_dump(void)
65
{
66
}
67
 
68
 
69
#else
70
 
71
 
72
/*
73
 * NULL pointer checking
74
 */
75
 
76
#define NULLCHECK(x) \
77
  if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x))
78
 
79
/*
80
 * Very extensive activity logging. Greatly improves bug detection speed but
81
 * costs a few Mbps if enabled.
82
 */
83
 
84
#define EV 64
85
 
86
static const char *ev[EV];
87
static unsigned long ev_a[EV],ev_b[EV];
88
static int ec = 0;
89
 
90
 
91
static void EVENT(const char *s,unsigned long a,unsigned long b)
92
{
93
        ev[ec] = s;
94
        ev_a[ec] = a;
95
        ev_b[ec] = b;
96
        ec = (ec+1) % EV;
97
}
98
 
99
 
100
static void event_dump(void)
101
{
102
        int n,i;
103
 
104
        printk(KERN_NOTICE "----- event dump follows -----\n");
105
        for (n = 0; n < EV; n++) {
106
                i = (ec+n) % EV;
107
                printk(KERN_NOTICE);
108
                printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
109
        }
110
        printk(KERN_NOTICE "----- event dump ends here -----\n");
111
}
112
 
113
 
114
#endif /* CONFIG_ATM_ZATM_DEBUG */
115
 
116
 
117
#define RING_BUSY       1       /* indication from do_tx that PDU has to be
118
                                   backlogged */
119
 
120
static struct atm_dev *zatm_boards = NULL;
121
static unsigned long dummy[2] = {0,0};
122
 
123
 
124
#define zin_n(r) inl(zatm_dev->base+r*4)
125
#define zin(r) inl(zatm_dev->base+uPD98401_##r*4)
126
#define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4)
127
#define zwait while (zin(CMR) & uPD98401_BUSY)
128
 
129
/* RX0, RX1, TX0, TX1 */
130
static const int mbx_entries[NR_MBX] = { 1024,1024,1024,1024 };
131
static const int mbx_esize[NR_MBX] = { 16,16,4,4 }; /* entry size in bytes */
132
 
133
#define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i])
134
 
135
 
136
/*-------------------------------- utilities --------------------------------*/
137
 
138
 
139
static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr)
140
{
141
        zwait;
142
        zout(value,CER);
143
        zout(uPD98401_IND_ACC | uPD98401_IA_BALL |
144
            (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
145
}
146
 
147
 
148
static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr)
149
{
150
        zwait;
151
        zout(uPD98401_IND_ACC | uPD98401_IA_BALL | uPD98401_IA_RW |
152
          (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
153
        zwait;
154
        return zin(CER);
155
}
156
 
157
 
158
/*------------------------------- free lists --------------------------------*/
159
 
160
 
161
/*
162
 * Free buffer head structure:
163
 *   [0] pointer to buffer (for SAR)
164
 *   [1] buffer descr link pointer (for SAR)
165
 *   [2] back pointer to skb (for poll_rx)
166
 *   [3] data
167
 *   ...
168
 */
169
 
170
struct rx_buffer_head {
171
        u32             buffer; /* pointer to buffer (for SAR) */
172
        u32             link;   /* buffer descriptor link pointer (for SAR) */
173
        struct sk_buff  *skb;   /* back pointer to skb (for poll_rx) */
174
};
175
 
176
 
177
static void refill_pool(struct atm_dev *dev,int pool)
178
{
179
        struct zatm_dev *zatm_dev;
180
        struct sk_buff *skb;
181
        struct rx_buffer_head *first;
182
        unsigned long flags;
183
        int align,offset,free,count,size;
184
 
185
        EVENT("refill_pool\n",0,0);
186
        zatm_dev = ZATM_DEV(dev);
187
        size = (64 << (pool <= ZATM_AAL5_POOL_BASE ? 0 :
188
            pool-ZATM_AAL5_POOL_BASE))+sizeof(struct rx_buffer_head);
189
        if (size < PAGE_SIZE) {
190
                align = 32; /* for 32 byte alignment */
191
                offset = sizeof(struct rx_buffer_head);
192
        }
193
        else {
194
                align = 4096;
195
                offset = zatm_dev->pool_info[pool].offset+
196
                    sizeof(struct rx_buffer_head);
197
        }
198
        size += align;
199
        spin_lock_irqsave(&zatm_dev->lock, flags);
200
        free = zpeekl(zatm_dev,zatm_dev->pool_base+2*pool) &
201
            uPD98401_RXFP_REMAIN;
202
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
203
        if (free >= zatm_dev->pool_info[pool].low_water) return;
204
        EVENT("starting ... POOL: 0x%x, 0x%x\n",
205
            zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
206
            zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
207
        EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
208
        count = 0;
209
        first = NULL;
210
        while (free < zatm_dev->pool_info[pool].high_water) {
211
                struct rx_buffer_head *head;
212
 
213
                skb = alloc_skb(size,GFP_ATOMIC);
214
                if (!skb) {
215
                        printk(KERN_WARNING DEV_LABEL "(Itf %d): got no new "
216
                            "skb (%d) with %d free\n",dev->number,size,free);
217
                        break;
218
                }
219
                skb_reserve(skb,(unsigned char *) ((((unsigned long) skb->data+
220
                    align+offset-1) & ~(unsigned long) (align-1))-offset)-
221
                    skb->data);
222
                head = (struct rx_buffer_head *) skb->data;
223
                skb_reserve(skb,sizeof(struct rx_buffer_head));
224
                if (!first) first = head;
225
                count++;
226
                head->buffer = virt_to_bus(skb->data);
227
                head->link = 0;
228
                head->skb = skb;
229
                EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb,
230
                    (unsigned long) head);
231
                spin_lock_irqsave(&zatm_dev->lock, flags);
232
                if (zatm_dev->last_free[pool])
233
                        ((struct rx_buffer_head *) (zatm_dev->last_free[pool]->
234
                            data))[-1].link = virt_to_bus(head);
235
                zatm_dev->last_free[pool] = skb;
236
                skb_queue_tail(&zatm_dev->pool[pool],skb);
237
                spin_unlock_irqrestore(&zatm_dev->lock, flags);
238
                free++;
239
        }
240
        if (first) {
241
                spin_lock_irqsave(&zatm_dev->lock, flags);
242
                zwait;
243
                zout(virt_to_bus(first),CER);
244
                zout(uPD98401_ADD_BAT | (pool << uPD98401_POOL_SHIFT) | count,
245
                    CMR);
246
                spin_unlock_irqrestore(&zatm_dev->lock, flags);
247
                EVENT ("POOL: 0x%x, 0x%x\n",
248
                    zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
249
                    zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
250
                EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
251
        }
252
}
253
 
254
 
255
static void drain_free(struct atm_dev *dev,int pool)
256
{
257
        skb_queue_purge(&ZATM_DEV(dev)->pool[pool]);
258
}
259
 
260
 
261
static int pool_index(int max_pdu)
262
{
263
        int i;
264
 
265
        if (max_pdu % ATM_CELL_PAYLOAD)
266
                printk(KERN_ERR DEV_LABEL ": driver error in pool_index: "
267
                    "max_pdu is %d\n",max_pdu);
268
        if (max_pdu > 65536) return -1;
269
        for (i = 0; (64 << i) < max_pdu; i++);
270
        return i+ZATM_AAL5_POOL_BASE;
271
}
272
 
273
 
274
/* use_pool isn't reentrant */
275
 
276
 
277
static void use_pool(struct atm_dev *dev,int pool)
278
{
279
        struct zatm_dev *zatm_dev;
280
        unsigned long flags;
281
        int size;
282
 
283
        zatm_dev = ZATM_DEV(dev);
284
        if (!(zatm_dev->pool_info[pool].ref_count++)) {
285
                skb_queue_head_init(&zatm_dev->pool[pool]);
286
                size = pool-ZATM_AAL5_POOL_BASE;
287
                if (size < 0) size = 0; /* 64B... */
288
                else if (size > 10) size = 10; /* ... 64kB */
289
                spin_lock_irqsave(&zatm_dev->lock, flags);
290
                zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) <<
291
                    uPD98401_RXFP_ALERT_SHIFT) |
292
                    (1 << uPD98401_RXFP_BTSZ_SHIFT) |
293
                    (size << uPD98401_RXFP_BFSZ_SHIFT),
294
                    zatm_dev->pool_base+pool*2);
295
                zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+
296
                    pool*2+1);
297
                spin_unlock_irqrestore(&zatm_dev->lock, flags);
298
                zatm_dev->last_free[pool] = NULL;
299
                refill_pool(dev,pool);
300
        }
301
        DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count);
302
}
303
 
304
 
305
static void unuse_pool(struct atm_dev *dev,int pool)
306
{
307
        if (!(--ZATM_DEV(dev)->pool_info[pool].ref_count))
308
                drain_free(dev,pool);
309
}
310
 
311
/*----------------------------------- RX ------------------------------------*/
312
 
313
 
314
#if 0
315
static void exception(struct atm_vcc *vcc)
316
{
317
   static int count = 0;
318
   struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev);
319
   struct zatm_vcc *zatm_vcc = ZATM_VCC(vcc);
320
   unsigned long *qrp;
321
   int i;
322
 
323
   if (count++ > 2) return;
324
   for (i = 0; i < 8; i++)
325
        printk("TX%d: 0x%08lx\n",i,
326
          zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+i));
327
   for (i = 0; i < 5; i++)
328
        printk("SH%d: 0x%08lx\n",i,
329
          zpeekl(zatm_dev,uPD98401_IM(zatm_vcc->shaper)+16*i));
330
   qrp = (unsigned long *) zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
331
     uPD98401_TXVC_QRP);
332
   printk("qrp=0x%08lx\n",(unsigned long) qrp);
333
   for (i = 0; i < 4; i++) printk("QRP[%d]: 0x%08lx",i,qrp[i]);
334
}
335
#endif
336
 
337
 
338
static const char *err_txt[] = {
339
        "No error",
340
        "RX buf underflow",
341
        "RX FIFO overrun",
342
        "Maximum len violation",
343
        "CRC error",
344
        "User abort",
345
        "Length violation",
346
        "T1 error",
347
        "Deactivated",
348
        "???",
349
        "???",
350
        "???",
351
        "???",
352
        "???",
353
        "???",
354
        "???"
355
};
356
 
357
 
358
static void poll_rx(struct atm_dev *dev,int mbx)
359
{
360
        struct zatm_dev *zatm_dev;
361
        unsigned long pos;
362
        u32 x;
363
        int error;
364
 
365
        EVENT("poll_rx\n",0,0);
366
        zatm_dev = ZATM_DEV(dev);
367
        pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
368
        while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
369
                u32 *here;
370
                struct sk_buff *skb;
371
                struct atm_vcc *vcc;
372
                int cells,size,chan;
373
 
374
                EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
375
                here = (u32 *) pos;
376
                if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
377
                        pos = zatm_dev->mbx_start[mbx];
378
                cells = here[0] & uPD98401_AAL5_SIZE;
379
#if 0
380
printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]);
381
{
382
unsigned long *x;
383
                printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev,
384
                      zatm_dev->pool_base),
385
                      zpeekl(zatm_dev,zatm_dev->pool_base+1));
386
                x = (unsigned long *) here[2];
387
                printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
388
                    x[0],x[1],x[2],x[3]);
389
}
390
#endif
391
                error = 0;
392
                if (here[3] & uPD98401_AAL5_ERR) {
393
                        error = (here[3] & uPD98401_AAL5_ES) >>
394
                            uPD98401_AAL5_ES_SHIFT;
395
                        if (error == uPD98401_AAL5_ES_DEACT ||
396
                            error == uPD98401_AAL5_ES_FREE) continue;
397
                }
398
EVENT("error code 0x%x/0x%x\n",(here[3] & uPD98401_AAL5_ES) >>
399
  uPD98401_AAL5_ES_SHIFT,error);
400
                skb = ((struct rx_buffer_head *) bus_to_virt(here[2]))->skb;
401
                __net_timestamp(skb);
402
#if 0
403
printk("[-3..0] 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",((unsigned *) skb->data)[-3],
404
  ((unsigned *) skb->data)[-2],((unsigned *) skb->data)[-1],
405
  ((unsigned *) skb->data)[0]);
406
#endif
407
                EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb,
408
                    (unsigned long) here);
409
#if 0
410
printk("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
411
#endif
412
                size = error ? 0 : ntohs(((__be16 *) skb->data)[cells*
413
                    ATM_CELL_PAYLOAD/sizeof(u16)-3]);
414
                EVENT("got skb 0x%lx, size %d\n",(unsigned long) skb,size);
415
                chan = (here[3] & uPD98401_AAL5_CHAN) >>
416
                    uPD98401_AAL5_CHAN_SHIFT;
417
                if (chan < zatm_dev->chans && zatm_dev->rx_map[chan]) {
418
                        int pos;
419
                        vcc = zatm_dev->rx_map[chan];
420
                        pos = ZATM_VCC(vcc)->pool;
421
                        if (skb == zatm_dev->last_free[pos])
422
                                zatm_dev->last_free[pos] = NULL;
423
                        skb_unlink(skb, zatm_dev->pool + pos);
424
                }
425
                else {
426
                        printk(KERN_ERR DEV_LABEL "(itf %d): RX indication "
427
                            "for non-existing channel\n",dev->number);
428
                        size = 0;
429
                        vcc = NULL;
430
                        event_dump();
431
                }
432
                if (error) {
433
                        static unsigned long silence = 0;
434
                        static int last_error = 0;
435
 
436
                        if (error != last_error ||
437
                            time_after(jiffies, silence)  || silence == 0){
438
                                printk(KERN_WARNING DEV_LABEL "(itf %d): "
439
                                    "chan %d error %s\n",dev->number,chan,
440
                                    err_txt[error]);
441
                                last_error = error;
442
                                silence = (jiffies+2*HZ)|1;
443
                        }
444
                        size = 0;
445
                }
446
                if (size && (size > cells*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER ||
447
                    size <= (cells-1)*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER)) {
448
                        printk(KERN_ERR DEV_LABEL "(itf %d): size %d with %d "
449
                            "cells\n",dev->number,size,cells);
450
                        size = 0;
451
                        event_dump();
452
                }
453
                if (size > ATM_MAX_AAL5_PDU) {
454
                        printk(KERN_ERR DEV_LABEL "(itf %d): size too big "
455
                            "(%d)\n",dev->number,size);
456
                        size = 0;
457
                        event_dump();
458
                }
459
                if (!size) {
460
                        dev_kfree_skb_irq(skb);
461
                        if (vcc) atomic_inc(&vcc->stats->rx_err);
462
                        continue;
463
                }
464
                if (!atm_charge(vcc,skb->truesize)) {
465
                        dev_kfree_skb_irq(skb);
466
                        continue;
467
                }
468
                skb->len = size;
469
                ATM_SKB(skb)->vcc = vcc;
470
                vcc->push(vcc,skb);
471
                atomic_inc(&vcc->stats->rx);
472
        }
473
        zout(pos & 0xffff,MTA(mbx));
474
#if 0 /* probably a stupid idea */
475
        refill_pool(dev,zatm_vcc->pool);
476
                /* maybe this saves us a few interrupts */
477
#endif
478
}
479
 
480
 
481
static int open_rx_first(struct atm_vcc *vcc)
482
{
483
        struct zatm_dev *zatm_dev;
484
        struct zatm_vcc *zatm_vcc;
485
        unsigned long flags;
486
        unsigned short chan;
487
        int cells;
488
 
489
        DPRINTK("open_rx_first (0x%x)\n",inb_p(0xc053));
490
        zatm_dev = ZATM_DEV(vcc->dev);
491
        zatm_vcc = ZATM_VCC(vcc);
492
        zatm_vcc->rx_chan = 0;
493
        if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0;
494
        if (vcc->qos.aal == ATM_AAL5) {
495
                if (vcc->qos.rxtp.max_sdu > 65464)
496
                        vcc->qos.rxtp.max_sdu = 65464;
497
                        /* fix this - we may want to receive 64kB SDUs
498
                           later */
499
                cells = (vcc->qos.rxtp.max_sdu+ATM_AAL5_TRAILER+
500
                    ATM_CELL_PAYLOAD-1)/ATM_CELL_PAYLOAD;
501
                zatm_vcc->pool = pool_index(cells*ATM_CELL_PAYLOAD);
502
        }
503
        else {
504
                cells = 1;
505
                zatm_vcc->pool = ZATM_AAL0_POOL;
506
        }
507
        if (zatm_vcc->pool < 0) return -EMSGSIZE;
508
        spin_lock_irqsave(&zatm_dev->lock, flags);
509
        zwait;
510
        zout(uPD98401_OPEN_CHAN,CMR);
511
        zwait;
512
        DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER));
513
        chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT;
514
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
515
        DPRINTK("chan is %d\n",chan);
516
        if (!chan) return -EAGAIN;
517
        use_pool(vcc->dev,zatm_vcc->pool);
518
        DPRINTK("pool %d\n",zatm_vcc->pool);
519
        /* set up VC descriptor */
520
        spin_lock_irqsave(&zatm_dev->lock, flags);
521
        zpokel(zatm_dev,zatm_vcc->pool << uPD98401_RXVC_POOL_SHIFT,
522
            chan*VC_SIZE/4);
523
        zpokel(zatm_dev,uPD98401_RXVC_OD | (vcc->qos.aal == ATM_AAL5 ?
524
            uPD98401_RXVC_AR : 0) | cells,chan*VC_SIZE/4+1);
525
        zpokel(zatm_dev,0,chan*VC_SIZE/4+2);
526
        zatm_vcc->rx_chan = chan;
527
        zatm_dev->rx_map[chan] = vcc;
528
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
529
        return 0;
530
}
531
 
532
 
533
static int open_rx_second(struct atm_vcc *vcc)
534
{
535
        struct zatm_dev *zatm_dev;
536
        struct zatm_vcc *zatm_vcc;
537
        unsigned long flags;
538
        int pos,shift;
539
 
540
        DPRINTK("open_rx_second (0x%x)\n",inb_p(0xc053));
541
        zatm_dev = ZATM_DEV(vcc->dev);
542
        zatm_vcc = ZATM_VCC(vcc);
543
        if (!zatm_vcc->rx_chan) return 0;
544
        spin_lock_irqsave(&zatm_dev->lock, flags);
545
        /* should also handle VPI @@@ */
546
        pos = vcc->vci >> 1;
547
        shift = (1-(vcc->vci & 1)) << 4;
548
        zpokel(zatm_dev,(zpeekl(zatm_dev,pos) & ~(0xffff << shift)) |
549
            ((zatm_vcc->rx_chan | uPD98401_RXLT_ENBL) << shift),pos);
550
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
551
        return 0;
552
}
553
 
554
 
555
static void close_rx(struct atm_vcc *vcc)
556
{
557
        struct zatm_dev *zatm_dev;
558
        struct zatm_vcc *zatm_vcc;
559
        unsigned long flags;
560
        int pos,shift;
561
 
562
        zatm_vcc = ZATM_VCC(vcc);
563
        zatm_dev = ZATM_DEV(vcc->dev);
564
        if (!zatm_vcc->rx_chan) return;
565
        DPRINTK("close_rx\n");
566
        /* disable receiver */
567
        if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) {
568
                spin_lock_irqsave(&zatm_dev->lock, flags);
569
                pos = vcc->vci >> 1;
570
                shift = (1-(vcc->vci & 1)) << 4;
571
                zpokel(zatm_dev,zpeekl(zatm_dev,pos) & ~(0xffff << shift),pos);
572
                zwait;
573
                zout(uPD98401_NOP,CMR);
574
                zwait;
575
                zout(uPD98401_NOP,CMR);
576
                spin_unlock_irqrestore(&zatm_dev->lock, flags);
577
        }
578
        spin_lock_irqsave(&zatm_dev->lock, flags);
579
        zwait;
580
        zout(uPD98401_DEACT_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
581
            uPD98401_CHAN_ADDR_SHIFT),CMR);
582
        zwait;
583
        udelay(10); /* why oh why ... ? */
584
        zout(uPD98401_CLOSE_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
585
            uPD98401_CHAN_ADDR_SHIFT),CMR);
586
        zwait;
587
        if (!(zin(CMR) & uPD98401_CHAN_ADDR))
588
                printk(KERN_CRIT DEV_LABEL "(itf %d): can't close RX channel "
589
                    "%d\n",vcc->dev->number,zatm_vcc->rx_chan);
590
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
591
        zatm_dev->rx_map[zatm_vcc->rx_chan] = NULL;
592
        zatm_vcc->rx_chan = 0;
593
        unuse_pool(vcc->dev,zatm_vcc->pool);
594
}
595
 
596
 
597
static int start_rx(struct atm_dev *dev)
598
{
599
        struct zatm_dev *zatm_dev;
600
        int size,i;
601
 
602
DPRINTK("start_rx\n");
603
        zatm_dev = ZATM_DEV(dev);
604
        size = sizeof(struct atm_vcc *)*zatm_dev->chans;
605
        zatm_dev->rx_map =  kzalloc(size,GFP_KERNEL);
606
        if (!zatm_dev->rx_map) return -ENOMEM;
607
        /* set VPI/VCI split (use all VCIs and give what's left to VPIs) */
608
        zpokel(zatm_dev,(1 << dev->ci_range.vci_bits)-1,uPD98401_VRR);
609
        /* prepare free buffer pools */
610
        for (i = 0; i <= ZATM_LAST_POOL; i++) {
611
                zatm_dev->pool_info[i].ref_count = 0;
612
                zatm_dev->pool_info[i].rqa_count = 0;
613
                zatm_dev->pool_info[i].rqu_count = 0;
614
                zatm_dev->pool_info[i].low_water = LOW_MARK;
615
                zatm_dev->pool_info[i].high_water = HIGH_MARK;
616
                zatm_dev->pool_info[i].offset = 0;
617
                zatm_dev->pool_info[i].next_off = 0;
618
                zatm_dev->pool_info[i].next_cnt = 0;
619
                zatm_dev->pool_info[i].next_thres = OFF_CNG_THRES;
620
        }
621
        return 0;
622
}
623
 
624
 
625
/*----------------------------------- TX ------------------------------------*/
626
 
627
 
628
static int do_tx(struct sk_buff *skb)
629
{
630
        struct atm_vcc *vcc;
631
        struct zatm_dev *zatm_dev;
632
        struct zatm_vcc *zatm_vcc;
633
        u32 *dsc;
634
        unsigned long flags;
635
 
636
        EVENT("do_tx\n",0,0);
637
        DPRINTK("sending skb %p\n",skb);
638
        vcc = ATM_SKB(skb)->vcc;
639
        zatm_dev = ZATM_DEV(vcc->dev);
640
        zatm_vcc = ZATM_VCC(vcc);
641
        EVENT("iovcnt=%d\n",skb_shinfo(skb)->nr_frags,0);
642
        spin_lock_irqsave(&zatm_dev->lock, flags);
643
        if (!skb_shinfo(skb)->nr_frags) {
644
                if (zatm_vcc->txing == RING_ENTRIES-1) {
645
                        spin_unlock_irqrestore(&zatm_dev->lock, flags);
646
                        return RING_BUSY;
647
                }
648
                zatm_vcc->txing++;
649
                dsc = zatm_vcc->ring+zatm_vcc->ring_curr;
650
                zatm_vcc->ring_curr = (zatm_vcc->ring_curr+RING_WORDS) &
651
                    (RING_ENTRIES*RING_WORDS-1);
652
                dsc[1] = 0;
653
                dsc[2] = skb->len;
654
                dsc[3] = virt_to_bus(skb->data);
655
                mb();
656
                dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP | uPD98401_TXPD_SM
657
                    | (vcc->qos.aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 |
658
                    (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ?
659
                    uPD98401_CLPM_1 : uPD98401_CLPM_0));
660
                EVENT("dsc (0x%lx)\n",(unsigned long) dsc,0);
661
        }
662
        else {
663
printk("NONONONOO!!!!\n");
664
                dsc = NULL;
665
#if 0
666
                u32 *put;
667
                int i;
668
 
669
                dsc = kmalloc(uPD98401_TXPD_SIZE * 2 +
670
                        uPD98401_TXBD_SIZE * ATM_SKB(skb)->iovcnt, GFP_ATOMIC);
671
                if (!dsc) {
672
                        if (vcc->pop)
673
                                vcc->pop(vcc, skb);
674
                        else
675
                                dev_kfree_skb_irq(skb);
676
                        return -EAGAIN;
677
                }
678
                /* @@@ should check alignment */
679
                put = dsc+8;
680
                dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP |
681
                    (vcc->aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 |
682
                    (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ?
683
                    uPD98401_CLPM_1 : uPD98401_CLPM_0));
684
                dsc[1] = 0;
685
                dsc[2] = ATM_SKB(skb)->iovcnt * uPD98401_TXBD_SIZE;
686
                dsc[3] = virt_to_bus(put);
687
                for (i = 0; i < ATM_SKB(skb)->iovcnt; i++) {
688
                        *put++ = ((struct iovec *) skb->data)[i].iov_len;
689
                        *put++ = virt_to_bus(((struct iovec *)
690
                            skb->data)[i].iov_base);
691
                }
692
                put[-2] |= uPD98401_TXBD_LAST;
693
#endif
694
        }
695
        ZATM_PRV_DSC(skb) = dsc;
696
        skb_queue_tail(&zatm_vcc->tx_queue,skb);
697
        DPRINTK("QRP=0x%08lx\n",zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
698
          uPD98401_TXVC_QRP));
699
        zwait;
700
        zout(uPD98401_TX_READY | (zatm_vcc->tx_chan <<
701
            uPD98401_CHAN_ADDR_SHIFT),CMR);
702
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
703
        EVENT("done\n",0,0);
704
        return 0;
705
}
706
 
707
 
708
static inline void dequeue_tx(struct atm_vcc *vcc)
709
{
710
        struct zatm_vcc *zatm_vcc;
711
        struct sk_buff *skb;
712
 
713
        EVENT("dequeue_tx\n",0,0);
714
        zatm_vcc = ZATM_VCC(vcc);
715
        skb = skb_dequeue(&zatm_vcc->tx_queue);
716
        if (!skb) {
717
                printk(KERN_CRIT DEV_LABEL "(itf %d): dequeue_tx but not "
718
                    "txing\n",vcc->dev->number);
719
                return;
720
        }
721
#if 0 /* @@@ would fail on CLP */
722
if (*ZATM_PRV_DSC(skb) != (uPD98401_TXPD_V | uPD98401_TXPD_DP |
723
  uPD98401_TXPD_SM | uPD98401_TXPD_AAL5)) printk("@#*$!!!!  (%08x)\n",
724
  *ZATM_PRV_DSC(skb));
725
#endif
726
        *ZATM_PRV_DSC(skb) = 0; /* mark as invalid */
727
        zatm_vcc->txing--;
728
        if (vcc->pop) vcc->pop(vcc,skb);
729
        else dev_kfree_skb_irq(skb);
730
        while ((skb = skb_dequeue(&zatm_vcc->backlog)))
731
                if (do_tx(skb) == RING_BUSY) {
732
                        skb_queue_head(&zatm_vcc->backlog,skb);
733
                        break;
734
                }
735
        atomic_inc(&vcc->stats->tx);
736
        wake_up(&zatm_vcc->tx_wait);
737
}
738
 
739
 
740
static void poll_tx(struct atm_dev *dev,int mbx)
741
{
742
        struct zatm_dev *zatm_dev;
743
        unsigned long pos;
744
        u32 x;
745
 
746
        EVENT("poll_tx\n",0,0);
747
        zatm_dev = ZATM_DEV(dev);
748
        pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
749
        while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
750
                int chan;
751
 
752
#if 1
753
                u32 data,*addr;
754
 
755
                EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
756
                addr = (u32 *) pos;
757
                data = *addr;
758
                chan = (data & uPD98401_TXI_CONN) >> uPD98401_TXI_CONN_SHIFT;
759
                EVENT("addr = 0x%lx, data = 0x%08x,",(unsigned long) addr,
760
                    data);
761
                EVENT("chan = %d\n",chan,0);
762
#else
763
NO !
764
                chan = (zatm_dev->mbx_start[mbx][pos >> 2] & uPD98401_TXI_CONN)
765
                >> uPD98401_TXI_CONN_SHIFT;
766
#endif
767
                if (chan < zatm_dev->chans && zatm_dev->tx_map[chan])
768
                        dequeue_tx(zatm_dev->tx_map[chan]);
769
                else {
770
                        printk(KERN_CRIT DEV_LABEL "(itf %d): TX indication "
771
                            "for non-existing channel %d\n",dev->number,chan);
772
                        event_dump();
773
                }
774
                if (((pos += 4) & 0xffff) == zatm_dev->mbx_end[mbx])
775
                        pos = zatm_dev->mbx_start[mbx];
776
        }
777
        zout(pos & 0xffff,MTA(mbx));
778
}
779
 
780
 
781
/*
782
 * BUG BUG BUG: Doesn't handle "new-style" rate specification yet.
783
 */
784
 
785
static int alloc_shaper(struct atm_dev *dev,int *pcr,int min,int max,int ubr)
786
{
787
        struct zatm_dev *zatm_dev;
788
        unsigned long flags;
789
        unsigned long i,m,c;
790
        int shaper;
791
 
792
        DPRINTK("alloc_shaper (min = %d, max = %d)\n",min,max);
793
        zatm_dev = ZATM_DEV(dev);
794
        if (!zatm_dev->free_shapers) return -EAGAIN;
795
        for (shaper = 0; !((zatm_dev->free_shapers >> shaper) & 1); shaper++);
796
        zatm_dev->free_shapers &= ~1 << shaper;
797
        if (ubr) {
798
                c = 5;
799
                i = m = 1;
800
                zatm_dev->ubr_ref_cnt++;
801
                zatm_dev->ubr = shaper;
802
                *pcr = 0;
803
        }
804
        else {
805
                if (min) {
806
                        if (min <= 255) {
807
                                i = min;
808
                                m = ATM_OC3_PCR;
809
                        }
810
                        else {
811
                                i = 255;
812
                                m = ATM_OC3_PCR*255/min;
813
                        }
814
                }
815
                else {
816
                        if (max > zatm_dev->tx_bw) max = zatm_dev->tx_bw;
817
                        if (max <= 255) {
818
                                i = max;
819
                                m = ATM_OC3_PCR;
820
                        }
821
                        else {
822
                                i = 255;
823
                                m = (ATM_OC3_PCR*255+max-1)/max;
824
                        }
825
                }
826
                if (i > m) {
827
                        printk(KERN_CRIT DEV_LABEL "shaper algorithm botched "
828
                            "[%d,%d] -> i=%ld,m=%ld\n",min,max,i,m);
829
                        m = i;
830
                }
831
                *pcr = i*ATM_OC3_PCR/m;
832
                c = 20; /* @@@ should use max_cdv ! */
833
                if ((min && *pcr < min) || (max && *pcr > max)) return -EINVAL;
834
                if (zatm_dev->tx_bw < *pcr) return -EAGAIN;
835
                zatm_dev->tx_bw -= *pcr;
836
        }
837
        spin_lock_irqsave(&zatm_dev->lock, flags);
838
        DPRINTK("i = %d, m = %d, PCR = %d\n",i,m,*pcr);
839
        zpokel(zatm_dev,(i << uPD98401_IM_I_SHIFT) | m,uPD98401_IM(shaper));
840
        zpokel(zatm_dev,c << uPD98401_PC_C_SHIFT,uPD98401_PC(shaper));
841
        zpokel(zatm_dev,0,uPD98401_X(shaper));
842
        zpokel(zatm_dev,0,uPD98401_Y(shaper));
843
        zpokel(zatm_dev,uPD98401_PS_E,uPD98401_PS(shaper));
844
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
845
        return shaper;
846
}
847
 
848
 
849
static void dealloc_shaper(struct atm_dev *dev,int shaper)
850
{
851
        struct zatm_dev *zatm_dev;
852
        unsigned long flags;
853
 
854
        zatm_dev = ZATM_DEV(dev);
855
        if (shaper == zatm_dev->ubr) {
856
                if (--zatm_dev->ubr_ref_cnt) return;
857
                zatm_dev->ubr = -1;
858
        }
859
        spin_lock_irqsave(&zatm_dev->lock, flags);
860
        zpokel(zatm_dev,zpeekl(zatm_dev,uPD98401_PS(shaper)) & ~uPD98401_PS_E,
861
            uPD98401_PS(shaper));
862
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
863
        zatm_dev->free_shapers |= 1 << shaper;
864
}
865
 
866
 
867
static void close_tx(struct atm_vcc *vcc)
868
{
869
        struct zatm_dev *zatm_dev;
870
        struct zatm_vcc *zatm_vcc;
871
        unsigned long flags;
872
        int chan;
873
 
874
        zatm_vcc = ZATM_VCC(vcc);
875
        zatm_dev = ZATM_DEV(vcc->dev);
876
        chan = zatm_vcc->tx_chan;
877
        if (!chan) return;
878
        DPRINTK("close_tx\n");
879
        if (skb_peek(&zatm_vcc->backlog)) {
880
                printk("waiting for backlog to drain ...\n");
881
                event_dump();
882
                wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->backlog));
883
        }
884
        if (skb_peek(&zatm_vcc->tx_queue)) {
885
                printk("waiting for TX queue to drain ...\n");
886
                event_dump();
887
                wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->tx_queue));
888
        }
889
        spin_lock_irqsave(&zatm_dev->lock, flags);
890
#if 0
891
        zwait;
892
        zout(uPD98401_DEACT_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
893
#endif
894
        zwait;
895
        zout(uPD98401_CLOSE_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
896
        zwait;
897
        if (!(zin(CMR) & uPD98401_CHAN_ADDR))
898
                printk(KERN_CRIT DEV_LABEL "(itf %d): can't close TX channel "
899
                    "%d\n",vcc->dev->number,chan);
900
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
901
        zatm_vcc->tx_chan = 0;
902
        zatm_dev->tx_map[chan] = NULL;
903
        if (zatm_vcc->shaper != zatm_dev->ubr) {
904
                zatm_dev->tx_bw += vcc->qos.txtp.min_pcr;
905
                dealloc_shaper(vcc->dev,zatm_vcc->shaper);
906
        }
907
        kfree(zatm_vcc->ring);
908
}
909
 
910
 
911
static int open_tx_first(struct atm_vcc *vcc)
912
{
913
        struct zatm_dev *zatm_dev;
914
        struct zatm_vcc *zatm_vcc;
915
        unsigned long flags;
916
        u32 *loop;
917
        unsigned short chan;
918
        int unlimited;
919
 
920
        DPRINTK("open_tx_first\n");
921
        zatm_dev = ZATM_DEV(vcc->dev);
922
        zatm_vcc = ZATM_VCC(vcc);
923
        zatm_vcc->tx_chan = 0;
924
        if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0;
925
        spin_lock_irqsave(&zatm_dev->lock, flags);
926
        zwait;
927
        zout(uPD98401_OPEN_CHAN,CMR);
928
        zwait;
929
        DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER));
930
        chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT;
931
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
932
        DPRINTK("chan is %d\n",chan);
933
        if (!chan) return -EAGAIN;
934
        unlimited = vcc->qos.txtp.traffic_class == ATM_UBR &&
935
            (!vcc->qos.txtp.max_pcr || vcc->qos.txtp.max_pcr == ATM_MAX_PCR ||
936
            vcc->qos.txtp.max_pcr >= ATM_OC3_PCR);
937
        if (unlimited && zatm_dev->ubr != -1) zatm_vcc->shaper = zatm_dev->ubr;
938
        else {
939
                int uninitialized_var(pcr);
940
 
941
                if (unlimited) vcc->qos.txtp.max_sdu = ATM_MAX_AAL5_PDU;
942
                if ((zatm_vcc->shaper = alloc_shaper(vcc->dev,&pcr,
943
                    vcc->qos.txtp.min_pcr,vcc->qos.txtp.max_pcr,unlimited))
944
                    < 0) {
945
                        close_tx(vcc);
946
                        return zatm_vcc->shaper;
947
                }
948
                if (pcr > ATM_OC3_PCR) pcr = ATM_OC3_PCR;
949
                vcc->qos.txtp.min_pcr = vcc->qos.txtp.max_pcr = pcr;
950
        }
951
        zatm_vcc->tx_chan = chan;
952
        skb_queue_head_init(&zatm_vcc->tx_queue);
953
        init_waitqueue_head(&zatm_vcc->tx_wait);
954
        /* initialize ring */
955
        zatm_vcc->ring = kzalloc(RING_SIZE,GFP_KERNEL);
956
        if (!zatm_vcc->ring) return -ENOMEM;
957
        loop = zatm_vcc->ring+RING_ENTRIES*RING_WORDS;
958
        loop[0] = uPD98401_TXPD_V;
959
        loop[1] = loop[2] = 0;
960
        loop[3] = virt_to_bus(zatm_vcc->ring);
961
        zatm_vcc->ring_curr = 0;
962
        zatm_vcc->txing = 0;
963
        skb_queue_head_init(&zatm_vcc->backlog);
964
        zpokel(zatm_dev,virt_to_bus(zatm_vcc->ring),
965
            chan*VC_SIZE/4+uPD98401_TXVC_QRP);
966
        return 0;
967
}
968
 
969
 
970
static int open_tx_second(struct atm_vcc *vcc)
971
{
972
        struct zatm_dev *zatm_dev;
973
        struct zatm_vcc *zatm_vcc;
974
        unsigned long flags;
975
 
976
        DPRINTK("open_tx_second\n");
977
        zatm_dev = ZATM_DEV(vcc->dev);
978
        zatm_vcc = ZATM_VCC(vcc);
979
        if (!zatm_vcc->tx_chan) return 0;
980
        /* set up VC descriptor */
981
        spin_lock_irqsave(&zatm_dev->lock, flags);
982
        zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4);
983
        zpokel(zatm_dev,uPD98401_TXVC_L | (zatm_vcc->shaper <<
984
            uPD98401_TXVC_SHP_SHIFT) | (vcc->vpi << uPD98401_TXVC_VPI_SHIFT) |
985
            vcc->vci,zatm_vcc->tx_chan*VC_SIZE/4+1);
986
        zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4+2);
987
        spin_unlock_irqrestore(&zatm_dev->lock, flags);
988
        zatm_dev->tx_map[zatm_vcc->tx_chan] = vcc;
989
        return 0;
990
}
991
 
992
 
993
static int start_tx(struct atm_dev *dev)
994
{
995
        struct zatm_dev *zatm_dev;
996
        int i;
997
 
998
        DPRINTK("start_tx\n");
999
        zatm_dev = ZATM_DEV(dev);
1000
        zatm_dev->tx_map = kmalloc(sizeof(struct atm_vcc *)*
1001
            zatm_dev->chans,GFP_KERNEL);
1002
        if (!zatm_dev->tx_map) return -ENOMEM;
1003
        zatm_dev->tx_bw = ATM_OC3_PCR;
1004
        zatm_dev->free_shapers = (1 << NR_SHAPERS)-1;
1005
        zatm_dev->ubr = -1;
1006
        zatm_dev->ubr_ref_cnt = 0;
1007
        /* initialize shapers */
1008
        for (i = 0; i < NR_SHAPERS; i++) zpokel(zatm_dev,0,uPD98401_PS(i));
1009
        return 0;
1010
}
1011
 
1012
 
1013
/*------------------------------- interrupts --------------------------------*/
1014
 
1015
 
1016
static irqreturn_t zatm_int(int irq,void *dev_id)
1017
{
1018
        struct atm_dev *dev;
1019
        struct zatm_dev *zatm_dev;
1020
        u32 reason;
1021
        int handled = 0;
1022
 
1023
        dev = dev_id;
1024
        zatm_dev = ZATM_DEV(dev);
1025
        while ((reason = zin(GSR))) {
1026
                handled = 1;
1027
                EVENT("reason 0x%x\n",reason,0);
1028
                if (reason & uPD98401_INT_PI) {
1029
                        EVENT("PHY int\n",0,0);
1030
                        dev->phy->interrupt(dev);
1031
                }
1032
                if (reason & uPD98401_INT_RQA) {
1033
                        unsigned long pools;
1034
                        int i;
1035
 
1036
                        pools = zin(RQA);
1037
                        EVENT("RQA (0x%08x)\n",pools,0);
1038
                        for (i = 0; pools; i++) {
1039
                                if (pools & 1) {
1040
                                        refill_pool(dev,i);
1041
                                        zatm_dev->pool_info[i].rqa_count++;
1042
                                }
1043
                                pools >>= 1;
1044
                        }
1045
                }
1046
                if (reason & uPD98401_INT_RQU) {
1047
                        unsigned long pools;
1048
                        int i;
1049
                        pools = zin(RQU);
1050
                        printk(KERN_WARNING DEV_LABEL "(itf %d): RQU 0x%08lx\n",
1051
                            dev->number,pools);
1052
                        event_dump();
1053
                        for (i = 0; pools; i++) {
1054
                                if (pools & 1) {
1055
                                        refill_pool(dev,i);
1056
                                        zatm_dev->pool_info[i].rqu_count++;
1057
                                }
1058
                                pools >>= 1;
1059
                        }
1060
                }
1061
                /* don't handle RD */
1062
                if (reason & uPD98401_INT_SPE)
1063
                        printk(KERN_ALERT DEV_LABEL "(itf %d): system parity "
1064
                            "error at 0x%08x\n",dev->number,zin(ADDR));
1065
                if (reason & uPD98401_INT_CPE)
1066
                        printk(KERN_ALERT DEV_LABEL "(itf %d): control memory "
1067
                            "parity error at 0x%08x\n",dev->number,zin(ADDR));
1068
                if (reason & uPD98401_INT_SBE) {
1069
                        printk(KERN_ALERT DEV_LABEL "(itf %d): system bus "
1070
                            "error at 0x%08x\n",dev->number,zin(ADDR));
1071
                        event_dump();
1072
                }
1073
                /* don't handle IND */
1074
                if (reason & uPD98401_INT_MF) {
1075
                        printk(KERN_CRIT DEV_LABEL "(itf %d): mailbox full "
1076
                            "(0x%x)\n",dev->number,(reason & uPD98401_INT_MF)
1077
                            >> uPD98401_INT_MF_SHIFT);
1078
                        event_dump();
1079
                            /* @@@ should try to recover */
1080
                }
1081
                if (reason & uPD98401_INT_MM) {
1082
                        if (reason & 1) poll_rx(dev,0);
1083
                        if (reason & 2) poll_rx(dev,1);
1084
                        if (reason & 4) poll_tx(dev,2);
1085
                        if (reason & 8) poll_tx(dev,3);
1086
                }
1087
                /* @@@ handle RCRn */
1088
        }
1089
        return IRQ_RETVAL(handled);
1090
}
1091
 
1092
 
1093
/*----------------------------- (E)EPROM access -----------------------------*/
1094
 
1095
 
1096
static void __devinit eprom_set(struct zatm_dev *zatm_dev,unsigned long value,
1097
    unsigned short cmd)
1098
{
1099
        int error;
1100
 
1101
        if ((error = pci_write_config_dword(zatm_dev->pci_dev,cmd,value)))
1102
                printk(KERN_ERR DEV_LABEL ": PCI write failed (0x%02x)\n",
1103
                    error);
1104
}
1105
 
1106
 
1107
static unsigned long __devinit eprom_get(struct zatm_dev *zatm_dev,
1108
    unsigned short cmd)
1109
{
1110
        unsigned int value;
1111
        int error;
1112
 
1113
        if ((error = pci_read_config_dword(zatm_dev->pci_dev,cmd,&value)))
1114
                printk(KERN_ERR DEV_LABEL ": PCI read failed (0x%02x)\n",
1115
                    error);
1116
        return value;
1117
}
1118
 
1119
 
1120
static void __devinit eprom_put_bits(struct zatm_dev *zatm_dev,
1121
    unsigned long data,int bits,unsigned short cmd)
1122
{
1123
        unsigned long value;
1124
        int i;
1125
 
1126
        for (i = bits-1; i >= 0; i--) {
1127
                value = ZEPROM_CS | (((data >> i) & 1) ? ZEPROM_DI : 0);
1128
                eprom_set(zatm_dev,value,cmd);
1129
                eprom_set(zatm_dev,value | ZEPROM_SK,cmd);
1130
                eprom_set(zatm_dev,value,cmd);
1131
        }
1132
}
1133
 
1134
 
1135
static void __devinit eprom_get_byte(struct zatm_dev *zatm_dev,
1136
    unsigned char *byte,unsigned short cmd)
1137
{
1138
        int i;
1139
 
1140
        *byte = 0;
1141
        for (i = 8; i; i--) {
1142
                eprom_set(zatm_dev,ZEPROM_CS,cmd);
1143
                eprom_set(zatm_dev,ZEPROM_CS | ZEPROM_SK,cmd);
1144
                *byte <<= 1;
1145
                if (eprom_get(zatm_dev,cmd) & ZEPROM_DO) *byte |= 1;
1146
                eprom_set(zatm_dev,ZEPROM_CS,cmd);
1147
        }
1148
}
1149
 
1150
 
1151
static unsigned char __devinit eprom_try_esi(struct atm_dev *dev,
1152
    unsigned short cmd,int offset,int swap)
1153
{
1154
        unsigned char buf[ZEPROM_SIZE];
1155
        struct zatm_dev *zatm_dev;
1156
        int i;
1157
 
1158
        zatm_dev = ZATM_DEV(dev);
1159
        for (i = 0; i < ZEPROM_SIZE; i += 2) {
1160
                eprom_set(zatm_dev,ZEPROM_CS,cmd); /* select EPROM */
1161
                eprom_put_bits(zatm_dev,ZEPROM_CMD_READ,ZEPROM_CMD_LEN,cmd);
1162
                eprom_put_bits(zatm_dev,i >> 1,ZEPROM_ADDR_LEN,cmd);
1163
                eprom_get_byte(zatm_dev,buf+i+swap,cmd);
1164
                eprom_get_byte(zatm_dev,buf+i+1-swap,cmd);
1165
                eprom_set(zatm_dev,0,cmd); /* deselect EPROM */
1166
        }
1167
        memcpy(dev->esi,buf+offset,ESI_LEN);
1168
        return memcmp(dev->esi,"\0\0\0\0\0",ESI_LEN); /* assumes ESI_LEN == 6 */
1169
}
1170
 
1171
 
1172
static void __devinit eprom_get_esi(struct atm_dev *dev)
1173
{
1174
        if (eprom_try_esi(dev,ZEPROM_V1_REG,ZEPROM_V1_ESI_OFF,1)) return;
1175
        (void) eprom_try_esi(dev,ZEPROM_V2_REG,ZEPROM_V2_ESI_OFF,0);
1176
}
1177
 
1178
 
1179
/*--------------------------------- entries ---------------------------------*/
1180
 
1181
 
1182
static int __devinit zatm_init(struct atm_dev *dev)
1183
{
1184
        struct zatm_dev *zatm_dev;
1185
        struct pci_dev *pci_dev;
1186
        unsigned short command;
1187
        int error,i,last;
1188
        unsigned long t0,t1,t2;
1189
 
1190
        DPRINTK(">zatm_init\n");
1191
        zatm_dev = ZATM_DEV(dev);
1192
        spin_lock_init(&zatm_dev->lock);
1193
        pci_dev = zatm_dev->pci_dev;
1194
        zatm_dev->base = pci_resource_start(pci_dev, 0);
1195
        zatm_dev->irq = pci_dev->irq;
1196
        if ((error = pci_read_config_word(pci_dev,PCI_COMMAND,&command))) {
1197
                printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%02x\n",
1198
                    dev->number,error);
1199
                return -EINVAL;
1200
        }
1201
        if ((error = pci_write_config_word(pci_dev,PCI_COMMAND,
1202
            command | PCI_COMMAND_IO | PCI_COMMAND_MASTER))) {
1203
                printk(KERN_ERR DEV_LABEL "(itf %d): can't enable IO (0x%02x)"
1204
                    "\n",dev->number,error);
1205
                return -EIO;
1206
        }
1207
        eprom_get_esi(dev);
1208
        printk(KERN_NOTICE DEV_LABEL "(itf %d): rev.%d,base=0x%x,irq=%d,",
1209
            dev->number,pci_dev->revision,zatm_dev->base,zatm_dev->irq);
1210
        /* reset uPD98401 */
1211
        zout(0,SWR);
1212
        while (!(zin(GSR) & uPD98401_INT_IND));
1213
        zout(uPD98401_GMR_ONE /*uPD98401_BURST4*/,GMR);
1214
        last = MAX_CRAM_SIZE;
1215
        for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) {
1216
                zpokel(zatm_dev,0x55555555,i);
1217
                if (zpeekl(zatm_dev,i) != 0x55555555) last = i;
1218
                else {
1219
                        zpokel(zatm_dev,0xAAAAAAAA,i);
1220
                        if (zpeekl(zatm_dev,i) != 0xAAAAAAAA) last = i;
1221
                        else zpokel(zatm_dev,i,i);
1222
                }
1223
        }
1224
        for (i = 0; i < last; i += RAM_INCREMENT)
1225
                if (zpeekl(zatm_dev,i) != i) break;
1226
        zatm_dev->mem = i << 2;
1227
        while (i) zpokel(zatm_dev,0,--i);
1228
        /* reset again to rebuild memory pointers */
1229
        zout(0,SWR);
1230
        while (!(zin(GSR) & uPD98401_INT_IND));
1231
        zout(uPD98401_GMR_ONE | uPD98401_BURST8 | uPD98401_BURST4 |
1232
            uPD98401_BURST2 | uPD98401_GMR_PM | uPD98401_GMR_DR,GMR);
1233
        /* TODO: should shrink allocation now */
1234
        printk("mem=%dkB,%s (",zatm_dev->mem >> 10,zatm_dev->copper ? "UTP" :
1235
            "MMF");
1236
        for (i = 0; i < ESI_LEN; i++)
1237
                printk("%02X%s",dev->esi[i],i == ESI_LEN-1 ? ")\n" : "-");
1238
        do {
1239
                unsigned long flags;
1240
 
1241
                spin_lock_irqsave(&zatm_dev->lock, flags);
1242
                t0 = zpeekl(zatm_dev,uPD98401_TSR);
1243
                udelay(10);
1244
                t1 = zpeekl(zatm_dev,uPD98401_TSR);
1245
                udelay(1010);
1246
                t2 = zpeekl(zatm_dev,uPD98401_TSR);
1247
                spin_unlock_irqrestore(&zatm_dev->lock, flags);
1248
        }
1249
        while (t0 > t1 || t1 > t2); /* loop if wrapping ... */
1250
        zatm_dev->khz = t2-2*t1+t0;
1251
        printk(KERN_NOTICE DEV_LABEL "(itf %d): uPD98401 %d.%d at %d.%03d "
1252
            "MHz\n",dev->number,
1253
            (zin(VER) & uPD98401_MAJOR) >> uPD98401_MAJOR_SHIFT,
1254
            zin(VER) & uPD98401_MINOR,zatm_dev->khz/1000,zatm_dev->khz % 1000);
1255
        return uPD98402_init(dev);
1256
}
1257
 
1258
 
1259
static int __devinit zatm_start(struct atm_dev *dev)
1260
{
1261
        struct zatm_dev *zatm_dev = ZATM_DEV(dev);
1262
        struct pci_dev *pdev = zatm_dev->pci_dev;
1263
        unsigned long curr;
1264
        int pools,vccs,rx;
1265
        int error, i, ld;
1266
 
1267
        DPRINTK("zatm_start\n");
1268
        zatm_dev->rx_map = zatm_dev->tx_map = NULL;
1269
        for (i = 0; i < NR_MBX; i++)
1270
                zatm_dev->mbx_start[i] = 0;
1271
        error = request_irq(zatm_dev->irq, zatm_int, IRQF_SHARED, DEV_LABEL, dev);
1272
        if (error < 0) {
1273
                printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1274
                    dev->number,zatm_dev->irq);
1275
                goto done;
1276
        }
1277
        /* define memory regions */
1278
        pools = NR_POOLS;
1279
        if (NR_SHAPERS*SHAPER_SIZE > pools*POOL_SIZE)
1280
                pools = NR_SHAPERS*SHAPER_SIZE/POOL_SIZE;
1281
        vccs = (zatm_dev->mem-NR_SHAPERS*SHAPER_SIZE-pools*POOL_SIZE)/
1282
            (2*VC_SIZE+RX_SIZE);
1283
        ld = -1;
1284
        for (rx = 1; rx < vccs; rx <<= 1) ld++;
1285
        dev->ci_range.vpi_bits = 0; /* @@@ no VPI for now */
1286
        dev->ci_range.vci_bits = ld;
1287
        dev->link_rate = ATM_OC3_PCR;
1288
        zatm_dev->chans = vccs; /* ??? */
1289
        curr = rx*RX_SIZE/4;
1290
        DPRINTK("RX pool 0x%08lx\n",curr);
1291
        zpokel(zatm_dev,curr,uPD98401_PMA); /* receive pool */
1292
        zatm_dev->pool_base = curr;
1293
        curr += pools*POOL_SIZE/4;
1294
        DPRINTK("Shapers 0x%08lx\n",curr);
1295
        zpokel(zatm_dev,curr,uPD98401_SMA); /* shapers */
1296
        curr += NR_SHAPERS*SHAPER_SIZE/4;
1297
        DPRINTK("Free    0x%08lx\n",curr);
1298
        zpokel(zatm_dev,curr,uPD98401_TOS); /* free pool */
1299
        printk(KERN_INFO DEV_LABEL "(itf %d): %d shapers, %d pools, %d RX, "
1300
            "%ld VCs\n",dev->number,NR_SHAPERS,pools,rx,
1301
            (zatm_dev->mem-curr*4)/VC_SIZE);
1302
        /* create mailboxes */
1303
        for (i = 0; i < NR_MBX; i++) {
1304
                void *mbx;
1305
                dma_addr_t mbx_dma;
1306
 
1307
                if (!mbx_entries[i])
1308
                        continue;
1309
                mbx = pci_alloc_consistent(pdev, 2*MBX_SIZE(i), &mbx_dma);
1310
                if (!mbx) {
1311
                        error = -ENOMEM;
1312
                        goto out;
1313
                }
1314
                /*
1315
                 * Alignment provided by pci_alloc_consistent() isn't enough
1316
                 * for this device.
1317
                 */
1318
                if (((unsigned long)mbx ^ mbx_dma) & 0xffff) {
1319
                        printk(KERN_ERR DEV_LABEL "(itf %d): system "
1320
                               "bus incompatible with driver\n", dev->number);
1321
                        pci_free_consistent(pdev, 2*MBX_SIZE(i), mbx, mbx_dma);
1322
                        error = -ENODEV;
1323
                        goto out;
1324
                }
1325
                DPRINTK("mbx@0x%08lx-0x%08lx\n", mbx, mbx + MBX_SIZE(i));
1326
                zatm_dev->mbx_start[i] = (unsigned long)mbx;
1327
                zatm_dev->mbx_dma[i] = mbx_dma;
1328
                zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) &
1329
                                        0xffff;
1330
                zout(mbx_dma >> 16, MSH(i));
1331
                zout(mbx_dma, MSL(i));
1332
                zout(zatm_dev->mbx_end[i], MBA(i));
1333
                zout((unsigned long)mbx & 0xffff, MTA(i));
1334
                zout((unsigned long)mbx & 0xffff, MWA(i));
1335
        }
1336
        error = start_tx(dev);
1337
        if (error)
1338
                goto out;
1339
        error = start_rx(dev);
1340
        if (error)
1341
                goto out_tx;
1342
        error = dev->phy->start(dev);
1343
        if (error)
1344
                goto out_rx;
1345
        zout(0xffffffff,IMR); /* enable interrupts */
1346
        /* enable TX & RX */
1347
        zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR);
1348
done:
1349
        return error;
1350
 
1351
out_rx:
1352
        kfree(zatm_dev->rx_map);
1353
out_tx:
1354
        kfree(zatm_dev->tx_map);
1355
out:
1356
        while (i-- > 0) {
1357
                pci_free_consistent(pdev, 2*MBX_SIZE(i),
1358
                                    (void *)zatm_dev->mbx_start[i],
1359
                                    zatm_dev->mbx_dma[i]);
1360
        }
1361
        free_irq(zatm_dev->irq, dev);
1362
        goto done;
1363
}
1364
 
1365
 
1366
static void zatm_close(struct atm_vcc *vcc)
1367
{
1368
        DPRINTK(">zatm_close\n");
1369
        if (!ZATM_VCC(vcc)) return;
1370
        clear_bit(ATM_VF_READY,&vcc->flags);
1371
        close_rx(vcc);
1372
        EVENT("close_tx\n",0,0);
1373
        close_tx(vcc);
1374
        DPRINTK("zatm_close: done waiting\n");
1375
        /* deallocate memory */
1376
        kfree(ZATM_VCC(vcc));
1377
        vcc->dev_data = NULL;
1378
        clear_bit(ATM_VF_ADDR,&vcc->flags);
1379
}
1380
 
1381
 
1382
static int zatm_open(struct atm_vcc *vcc)
1383
{
1384
        struct zatm_dev *zatm_dev;
1385
        struct zatm_vcc *zatm_vcc;
1386
        short vpi = vcc->vpi;
1387
        int vci = vcc->vci;
1388
        int error;
1389
 
1390
        DPRINTK(">zatm_open\n");
1391
        zatm_dev = ZATM_DEV(vcc->dev);
1392
        if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1393
                vcc->dev_data = NULL;
1394
        if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1395
                set_bit(ATM_VF_ADDR,&vcc->flags);
1396
        if (vcc->qos.aal != ATM_AAL5) return -EINVAL; /* @@@ AAL0 */
1397
        DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1398
            vcc->vci);
1399
        if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1400
                zatm_vcc = kmalloc(sizeof(struct zatm_vcc),GFP_KERNEL);
1401
                if (!zatm_vcc) {
1402
                        clear_bit(ATM_VF_ADDR,&vcc->flags);
1403
                        return -ENOMEM;
1404
                }
1405
                vcc->dev_data = zatm_vcc;
1406
                ZATM_VCC(vcc)->tx_chan = 0; /* for zatm_close after open_rx */
1407
                if ((error = open_rx_first(vcc))) {
1408
                        zatm_close(vcc);
1409
                        return error;
1410
                }
1411
                if ((error = open_tx_first(vcc))) {
1412
                        zatm_close(vcc);
1413
                        return error;
1414
                }
1415
        }
1416
        if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1417
        if ((error = open_rx_second(vcc))) {
1418
                zatm_close(vcc);
1419
                return error;
1420
        }
1421
        if ((error = open_tx_second(vcc))) {
1422
                zatm_close(vcc);
1423
                return error;
1424
        }
1425
        set_bit(ATM_VF_READY,&vcc->flags);
1426
        return 0;
1427
}
1428
 
1429
 
1430
static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags)
1431
{
1432
        printk("Not yet implemented\n");
1433
        return -ENOSYS;
1434
        /* @@@ */
1435
}
1436
 
1437
 
1438
static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1439
{
1440
        struct zatm_dev *zatm_dev;
1441
        unsigned long flags;
1442
 
1443
        zatm_dev = ZATM_DEV(dev);
1444
        switch (cmd) {
1445
                case ZATM_GETPOOLZ:
1446
                        if (!capable(CAP_NET_ADMIN)) return -EPERM;
1447
                        /* fall through */
1448
                case ZATM_GETPOOL:
1449
                        {
1450
                                struct zatm_pool_info info;
1451
                                int pool;
1452
 
1453
                                if (get_user(pool,
1454
                                    &((struct zatm_pool_req __user *) arg)->pool_num))
1455
                                        return -EFAULT;
1456
                                if (pool < 0 || pool > ZATM_LAST_POOL)
1457
                                        return -EINVAL;
1458
                                spin_lock_irqsave(&zatm_dev->lock, flags);
1459
                                info = zatm_dev->pool_info[pool];
1460
                                if (cmd == ZATM_GETPOOLZ) {
1461
                                        zatm_dev->pool_info[pool].rqa_count = 0;
1462
                                        zatm_dev->pool_info[pool].rqu_count = 0;
1463
                                }
1464
                                spin_unlock_irqrestore(&zatm_dev->lock, flags);
1465
                                return copy_to_user(
1466
                                    &((struct zatm_pool_req __user *) arg)->info,
1467
                                    &info,sizeof(info)) ? -EFAULT : 0;
1468
                        }
1469
                case ZATM_SETPOOL:
1470
                        {
1471
                                struct zatm_pool_info info;
1472
                                int pool;
1473
 
1474
                                if (!capable(CAP_NET_ADMIN)) return -EPERM;
1475
                                if (get_user(pool,
1476
                                    &((struct zatm_pool_req __user *) arg)->pool_num))
1477
                                        return -EFAULT;
1478
                                if (pool < 0 || pool > ZATM_LAST_POOL)
1479
                                        return -EINVAL;
1480
                                if (copy_from_user(&info,
1481
                                    &((struct zatm_pool_req __user *) arg)->info,
1482
                                    sizeof(info))) return -EFAULT;
1483
                                if (!info.low_water)
1484
                                        info.low_water = zatm_dev->
1485
                                            pool_info[pool].low_water;
1486
                                if (!info.high_water)
1487
                                        info.high_water = zatm_dev->
1488
                                            pool_info[pool].high_water;
1489
                                if (!info.next_thres)
1490
                                        info.next_thres = zatm_dev->
1491
                                            pool_info[pool].next_thres;
1492
                                if (info.low_water >= info.high_water ||
1493
                                    info.low_water < 0)
1494
                                        return -EINVAL;
1495
                                spin_lock_irqsave(&zatm_dev->lock, flags);
1496
                                zatm_dev->pool_info[pool].low_water =
1497
                                    info.low_water;
1498
                                zatm_dev->pool_info[pool].high_water =
1499
                                    info.high_water;
1500
                                zatm_dev->pool_info[pool].next_thres =
1501
                                    info.next_thres;
1502
                                spin_unlock_irqrestore(&zatm_dev->lock, flags);
1503
                                return 0;
1504
                        }
1505
                default:
1506
                        if (!dev->phy->ioctl) return -ENOIOCTLCMD;
1507
                        return dev->phy->ioctl(dev,cmd,arg);
1508
        }
1509
}
1510
 
1511
 
1512
static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname,
1513
    void __user *optval,int optlen)
1514
{
1515
        return -EINVAL;
1516
}
1517
 
1518
 
1519
static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname,
1520
    void __user *optval,int optlen)
1521
{
1522
        return -EINVAL;
1523
}
1524
 
1525
static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb)
1526
{
1527
        int error;
1528
 
1529
        EVENT(">zatm_send 0x%lx\n",(unsigned long) skb,0);
1530
        if (!ZATM_VCC(vcc)->tx_chan || !test_bit(ATM_VF_READY,&vcc->flags)) {
1531
                if (vcc->pop) vcc->pop(vcc,skb);
1532
                else dev_kfree_skb(skb);
1533
                return -EINVAL;
1534
        }
1535
        if (!skb) {
1536
                printk(KERN_CRIT "!skb in zatm_send ?\n");
1537
                if (vcc->pop) vcc->pop(vcc,skb);
1538
                return -EINVAL;
1539
        }
1540
        ATM_SKB(skb)->vcc = vcc;
1541
        error = do_tx(skb);
1542
        if (error != RING_BUSY) return error;
1543
        skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb);
1544
        return 0;
1545
}
1546
 
1547
 
1548
static void zatm_phy_put(struct atm_dev *dev,unsigned char value,
1549
    unsigned long addr)
1550
{
1551
        struct zatm_dev *zatm_dev;
1552
 
1553
        zatm_dev = ZATM_DEV(dev);
1554
        zwait;
1555
        zout(value,CER);
1556
        zout(uPD98401_IND_ACC | uPD98401_IA_B0 |
1557
            (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1558
}
1559
 
1560
 
1561
static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr)
1562
{
1563
        struct zatm_dev *zatm_dev;
1564
 
1565
        zatm_dev = ZATM_DEV(dev);
1566
        zwait;
1567
        zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW |
1568
          (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1569
        zwait;
1570
        return zin(CER) & 0xff;
1571
}
1572
 
1573
 
1574
static const struct atmdev_ops ops = {
1575
        .open           = zatm_open,
1576
        .close          = zatm_close,
1577
        .ioctl          = zatm_ioctl,
1578
        .getsockopt     = zatm_getsockopt,
1579
        .setsockopt     = zatm_setsockopt,
1580
        .send           = zatm_send,
1581
        .phy_put        = zatm_phy_put,
1582
        .phy_get        = zatm_phy_get,
1583
        .change_qos     = zatm_change_qos,
1584
};
1585
 
1586
static int __devinit zatm_init_one(struct pci_dev *pci_dev,
1587
                                   const struct pci_device_id *ent)
1588
{
1589
        struct atm_dev *dev;
1590
        struct zatm_dev *zatm_dev;
1591
        int ret = -ENOMEM;
1592
 
1593
        zatm_dev = kmalloc(sizeof(*zatm_dev), GFP_KERNEL);
1594
        if (!zatm_dev) {
1595
                printk(KERN_EMERG "%s: memory shortage\n", DEV_LABEL);
1596
                goto out;
1597
        }
1598
 
1599
        dev = atm_dev_register(DEV_LABEL, &ops, -1, NULL);
1600
        if (!dev)
1601
                goto out_free;
1602
 
1603
        ret = pci_enable_device(pci_dev);
1604
        if (ret < 0)
1605
                goto out_deregister;
1606
 
1607
        ret = pci_request_regions(pci_dev, DEV_LABEL);
1608
        if (ret < 0)
1609
                goto out_disable;
1610
 
1611
        zatm_dev->pci_dev = pci_dev;
1612
        dev->dev_data = zatm_dev;
1613
        zatm_dev->copper = (int)ent->driver_data;
1614
        if ((ret = zatm_init(dev)) || (ret = zatm_start(dev)))
1615
                goto out_release;
1616
 
1617
        pci_set_drvdata(pci_dev, dev);
1618
        zatm_dev->more = zatm_boards;
1619
        zatm_boards = dev;
1620
        ret = 0;
1621
out:
1622
        return ret;
1623
 
1624
out_release:
1625
        pci_release_regions(pci_dev);
1626
out_disable:
1627
        pci_disable_device(pci_dev);
1628
out_deregister:
1629
        atm_dev_deregister(dev);
1630
out_free:
1631
        kfree(zatm_dev);
1632
        goto out;
1633
}
1634
 
1635
 
1636
MODULE_LICENSE("GPL");
1637
 
1638
static struct pci_device_id zatm_pci_tbl[] __devinitdata = {
1639
        { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1221,
1640
                PCI_ANY_ID, PCI_ANY_ID, 0, 0, ZATM_COPPER },
1641
        { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1225,
1642
                PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1643
        { 0, }
1644
};
1645
MODULE_DEVICE_TABLE(pci, zatm_pci_tbl);
1646
 
1647
static struct pci_driver zatm_driver = {
1648
        .name =         DEV_LABEL,
1649
        .id_table =     zatm_pci_tbl,
1650
        .probe =        zatm_init_one,
1651
};
1652
 
1653
static int __init zatm_init_module(void)
1654
{
1655
        return pci_register_driver(&zatm_driver);
1656
}
1657
 
1658
module_init(zatm_init_module);
1659
/* module_exit not defined so not unloadable */

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.