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