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