1 /* drivers/atm/zatm.c - ZeitNet ZN122x device driver */
3 /* Written 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
6 #include <linux/config.h>
7 #include <linux/module.h>
8 #include <linux/sched.h>
9 #include <linux/kernel.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 <asm/byteorder.h>
25 #include <asm/system.h>
26 #include <asm/string.h>
28 #include <asm/uaccess.h>
40 * - support 64 kB SDUs (will have to use multibuffer batches then :-( )
41 * - proper use of CDV, credit = max(1,CDVT*PCR)
43 * - better receive timestamps
48 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
50 #define DPRINTK(format,args...)
54 #ifndef CONFIG_ATM_ZATM_DEBUG
62 static void event_dump(void)
71 * NULL pointer checking
74 #define NULLCHECK(x) \
75 if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x))
78 * Very extensive activity logging. Greatly improves bug detection speed but
79 * costs a few Mbps if enabled.
84 static const char *ev
[EV
];
85 static unsigned long ev_a
[EV
],ev_b
[EV
];
89 static void EVENT(const char *s
,unsigned long a
,unsigned long b
)
98 static void event_dump(void)
102 printk(KERN_NOTICE
"----- event dump follows -----\n");
103 for (n
= 0; n
< EV
; n
++) {
106 printk(ev
[i
] ? ev
[i
] : "(null)",ev_a
[i
],ev_b
[i
]);
108 printk(KERN_NOTICE
"----- event dump ends here -----\n");
112 #endif /* CONFIG_ATM_ZATM_DEBUG */
115 #define RING_BUSY 1 /* indication from do_tx that PDU has to be
118 static struct atm_dev
*zatm_boards
= NULL
;
119 static unsigned long dummy
[2] = {0,0};
122 #define zin_n(r) inl(zatm_dev->base+r*4)
123 #define zin(r) inl(zatm_dev->base+uPD98401_##r*4)
124 #define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4)
125 #define zwait while (zin(CMR) & uPD98401_BUSY)
127 /* RX0, RX1, TX0, TX1 */
128 static const int mbx_entries
[NR_MBX
] = { 1024,1024,1024,1024 };
129 static const int mbx_esize
[NR_MBX
] = { 16,16,4,4 }; /* entry size in bytes */
131 #define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i])
134 /*-------------------------------- utilities --------------------------------*/
137 static void zpokel(struct zatm_dev
*zatm_dev
,u32 value
,u32 addr
)
141 zout(uPD98401_IND_ACC
| uPD98401_IA_BALL
|
142 (uPD98401_IA_TGT_CM
<< uPD98401_IA_TGT_SHIFT
) | addr
,CMR
);
146 static u32
zpeekl(struct zatm_dev
*zatm_dev
,u32 addr
)
149 zout(uPD98401_IND_ACC
| uPD98401_IA_BALL
| uPD98401_IA_RW
|
150 (uPD98401_IA_TGT_CM
<< uPD98401_IA_TGT_SHIFT
) | addr
,CMR
);
156 /*------------------------------- free lists --------------------------------*/
160 * Free buffer head structure:
161 * [0] pointer to buffer (for SAR)
162 * [1] buffer descr link pointer (for SAR)
163 * [2] back pointer to skb (for poll_rx)
168 struct rx_buffer_head
{
169 u32 buffer
; /* pointer to buffer (for SAR) */
170 u32 link
; /* buffer descriptor link pointer (for SAR) */
171 struct sk_buff
*skb
; /* back pointer to skb (for poll_rx) */
175 static void refill_pool(struct atm_dev
*dev
,int pool
)
177 struct zatm_dev
*zatm_dev
;
179 struct rx_buffer_head
*first
;
181 int align
,offset
,free
,count
,size
;
183 EVENT("refill_pool\n",0,0);
184 zatm_dev
= ZATM_DEV(dev
);
185 size
= (64 << (pool
<= ZATM_AAL5_POOL_BASE
? 0 :
186 pool
-ZATM_AAL5_POOL_BASE
))+sizeof(struct rx_buffer_head
);
187 if (size
< PAGE_SIZE
) {
188 align
= 32; /* for 32 byte alignment */
189 offset
= sizeof(struct rx_buffer_head
);
193 offset
= zatm_dev
->pool_info
[pool
].offset
+
194 sizeof(struct rx_buffer_head
);
199 free
= zpeekl(zatm_dev
,zatm_dev
->pool_base
+2*pool
) &
200 uPD98401_RXFP_REMAIN
;
201 restore_flags(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]);
209 while (free
< zatm_dev
->pool_info
[pool
].high_water
) {
210 struct rx_buffer_head
*head
;
212 skb
= alloc_skb(size
,GFP_ATOMIC
);
214 printk(KERN_WARNING DEV_LABEL
"(Itf %d): got no new "
215 "skb (%d) with %d free\n",dev
->number
,size
,free
);
218 skb_reserve(skb
,(unsigned char *) ((((unsigned long) skb
->data
+
219 align
+offset
-1) & ~(unsigned long) (align
-1))-offset
)-
221 head
= (struct rx_buffer_head
*) skb
->data
;
222 skb_reserve(skb
,sizeof(struct rx_buffer_head
));
223 if (!first
) first
= head
;
225 head
->buffer
= virt_to_bus(skb
->data
);
228 EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb
,
229 (unsigned long) head
);
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 restore_flags(flags
);
242 zout(virt_to_bus(first
),CER
);
243 zout(uPD98401_ADD_BAT
| (pool
<< uPD98401_POOL_SHIFT
) | count
,
245 restore_flags(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]);
254 static void drain_free(struct atm_dev
*dev
,int pool
)
258 while ((skb
= skb_dequeue(&ZATM_DEV(dev
)->pool
[pool
]))) kfree_skb(skb
);
262 static int pool_index(int max_pdu
)
266 if (max_pdu
% ATM_CELL_PAYLOAD
)
267 printk(KERN_ERR DEV_LABEL
": driver error in pool_index: "
268 "max_pdu is %d\n",max_pdu
);
269 if (max_pdu
> 65536) return -1;
270 for (i
= 0; (64 << i
) < max_pdu
; i
++);
271 return i
+ZATM_AAL5_POOL_BASE
;
275 /* use_pool isn't reentrant */
278 static void use_pool(struct atm_dev
*dev
,int pool
)
280 struct zatm_dev
*zatm_dev
;
284 zatm_dev
= ZATM_DEV(dev
);
285 if (!(zatm_dev
->pool_info
[pool
].ref_count
++)) {
286 skb_queue_head_init(&zatm_dev
->pool
[pool
]);
287 size
= pool
-ZATM_AAL5_POOL_BASE
;
288 if (size
< 0) size
= 0; /* 64B... */
289 else if (size
> 10) size
= 10; /* ... 64kB */
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
+
299 restore_flags(flags
);
300 zatm_dev
->last_free
[pool
] = NULL
;
301 refill_pool(dev
,pool
);
303 DPRINTK("pool %d: %d\n",pool
,zatm_dev
->pool_info
[pool
].ref_count
);
307 static void unuse_pool(struct atm_dev
*dev
,int pool
)
309 if (!(--ZATM_DEV(dev
)->pool_info
[pool
].ref_count
))
310 drain_free(dev
,pool
);
314 static void zatm_feedback(struct atm_vcc
*vcc
,struct sk_buff
*skb
,
315 unsigned long start
,unsigned long dest
,int len
)
317 struct zatm_pool_info
*pool
;
318 unsigned long offset
,flags
;
320 DPRINTK("start 0x%08lx dest 0x%08lx len %d\n",start
,dest
,len
);
321 if (len
< PAGE_SIZE
) return;
322 pool
= &ZATM_DEV(vcc
->dev
)->pool_info
[ZATM_VCC(vcc
)->pool
];
323 offset
= (dest
-start
) & (PAGE_SIZE
-1);
326 if (!offset
|| pool
->offset
== offset
) {
328 restore_flags(flags
);
331 if (offset
!= pool
->next_off
) {
332 pool
->next_off
= offset
;
334 restore_flags(flags
);
337 if (++pool
->next_cnt
>= pool
->next_thres
) {
338 pool
->offset
= pool
->next_off
;
341 restore_flags(flags
);
345 /*----------------------- high-precision timestamps -------------------------*/
348 #ifdef CONFIG_ATM_ZATM_EXACT_TS
350 static struct timer_list sync_timer
;
354 * Note: the exact time is not normalized, i.e. tv_usec can be > 1000000.
355 * This must be handled by higher layers.
358 static inline struct timeval
exact_time(struct zatm_dev
*zatm_dev
,u32 ticks
)
362 tmp
= zatm_dev
->last_time
;
363 tmp
.tv_usec
+= ((s64
) (ticks
-zatm_dev
->last_clk
)*
364 (s64
) zatm_dev
->factor
) >> TIMER_SHIFT
;
369 static void zatm_clock_sync(unsigned long dummy
)
371 struct atm_dev
*atm_dev
;
372 struct zatm_dev
*zatm_dev
;
374 for (atm_dev
= zatm_boards
; atm_dev
; atm_dev
= zatm_dev
->more
) {
375 unsigned long flags
,interval
;
377 struct timeval now
,expected
;
380 zatm_dev
= ZATM_DEV(atm_dev
);
383 ticks
= zpeekl(zatm_dev
,uPD98401_TSR
);
384 do_gettimeofday(&now
);
385 restore_flags(flags
);
386 expected
= exact_time(zatm_dev
,ticks
);
387 diff
= 1000000*(expected
.tv_sec
-now
.tv_sec
)+
388 (expected
.tv_usec
-now
.tv_usec
);
389 zatm_dev
->timer_history
[zatm_dev
->th_curr
].real
= now
;
390 zatm_dev
->timer_history
[zatm_dev
->th_curr
].expected
= expected
;
391 zatm_dev
->th_curr
= (zatm_dev
->th_curr
+1) &
392 (ZATM_TIMER_HISTORY_SIZE
-1);
393 interval
= 1000000*(now
.tv_sec
-zatm_dev
->last_real_time
.tv_sec
)
394 +(now
.tv_usec
-zatm_dev
->last_real_time
.tv_usec
);
395 if (diff
>= -ADJ_REP_THRES
&& diff
<= ADJ_REP_THRES
)
396 zatm_dev
->timer_diffs
= 0;
398 #ifndef AGGRESSIVE_DEBUGGING
399 if (++zatm_dev
->timer_diffs
>= ADJ_MSG_THRES
)
402 zatm_dev
->timer_diffs
= 0;
403 printk(KERN_INFO DEV_LABEL
": TSR update after %ld us:"
404 " calculation differed by %d us\n",interval
,diff
);
405 #ifdef AGGRESSIVE_DEBUGGING
406 printk(KERN_DEBUG
" %d.%08d -> %d.%08d (%lu)\n",
407 zatm_dev
->last_real_time
.tv_sec
,
408 zatm_dev
->last_real_time
.tv_usec
,
409 now
.tv_sec
,now
.tv_usec
,interval
);
410 printk(KERN_DEBUG
" %u -> %u (%d)\n",
411 zatm_dev
->last_clk
,ticks
,ticks
-zatm_dev
->last_clk
);
412 printk(KERN_DEBUG
" factor %u\n",zatm_dev
->factor
);
415 if (diff
< -ADJ_IGN_THRES
|| diff
> ADJ_IGN_THRES
) {
416 /* filter out any major changes (e.g. time zone setup and
418 zatm_dev
->last_time
= now
;
420 (1000 << TIMER_SHIFT
)/(zatm_dev
->khz
+1);
423 zatm_dev
->last_time
= expected
;
425 * Is the accuracy of udelay really only about 1:300 on
426 * a 90 MHz Pentium ? Well, the following line avoids
427 * the problem, but ...
429 * What it does is simply:
431 * zatm_dev->factor = (interval << TIMER_SHIFT)/
432 * (ticks-zatm_dev->last_clk);
434 #define S(x) #x /* "stringification" ... */
436 asm("movl %2,%%ebx\n\t"
438 "xorl %%edx,%%edx\n\t"
439 "shldl $" SX(TIMER_SHIFT
) ",%1,%%edx\n\t"
440 "shl $" SX(TIMER_SHIFT
) ",%1\n\t"
442 : "=eax" (zatm_dev
->factor
)
443 : "eax" (interval
-diff
),"g" (ticks
),
444 "g" (zatm_dev
->last_clk
)
448 #ifdef AGGRESSIVE_DEBUGGING
449 printk(KERN_DEBUG
" (%ld << %d)/(%u-%u) = %u\n",
450 interval
,TIMER_SHIFT
,ticks
,zatm_dev
->last_clk
,
454 zatm_dev
->last_real_time
= now
;
455 zatm_dev
->last_clk
= ticks
;
457 mod_timer(&sync_timer
,sync_timer
.expires
+POLL_INTERVAL
*HZ
);
461 static void __init
zatm_clock_init(struct zatm_dev
*zatm_dev
)
463 static int start_timer
= 1;
466 zatm_dev
->factor
= (1000 << TIMER_SHIFT
)/(zatm_dev
->khz
+1);
467 zatm_dev
->timer_diffs
= 0;
468 memset(zatm_dev
->timer_history
,0,sizeof(zatm_dev
->timer_history
));
469 zatm_dev
->th_curr
= 0;
472 do_gettimeofday(&zatm_dev
->last_time
);
473 zatm_dev
->last_clk
= zpeekl(zatm_dev
,uPD98401_TSR
);
476 init_timer(&sync_timer
);
477 sync_timer
.expires
= jiffies
+POLL_INTERVAL
*HZ
;
478 sync_timer
.function
= zatm_clock_sync
;
479 add_timer(&sync_timer
);
481 restore_flags(flags
);
488 /*----------------------------------- RX ------------------------------------*/
492 static void exception(struct atm_vcc
*vcc
)
494 static int count
= 0;
495 struct zatm_dev
*zatm_dev
= ZATM_DEV(vcc
->dev
);
496 struct zatm_vcc
*zatm_vcc
= ZATM_VCC(vcc
);
500 if (count
++ > 2) return;
501 for (i
= 0; i
< 8; i
++)
502 printk("TX%d: 0x%08lx\n",i
,
503 zpeekl(zatm_dev
,zatm_vcc
->tx_chan
*VC_SIZE
/4+i
));
504 for (i
= 0; i
< 5; i
++)
505 printk("SH%d: 0x%08lx\n",i
,
506 zpeekl(zatm_dev
,uPD98401_IM(zatm_vcc
->shaper
)+16*i
));
507 qrp
= (unsigned long *) zpeekl(zatm_dev
,zatm_vcc
->tx_chan
*VC_SIZE
/4+
509 printk("qrp=0x%08lx\n",(unsigned long) qrp
);
510 for (i
= 0; i
< 4; i
++) printk("QRP[%d]: 0x%08lx",i
,qrp
[i
]);
515 static const char *err_txt
[] = {
519 "Maximum len violation",
535 static void poll_rx(struct atm_dev
*dev
,int mbx
)
537 struct zatm_dev
*zatm_dev
;
542 EVENT("poll_rx\n",0,0);
543 zatm_dev
= ZATM_DEV(dev
);
544 pos
= (zatm_dev
->mbx_start
[mbx
] & ~0xffffUL
) | zin(MTA(mbx
));
545 while (x
= zin(MWA(mbx
)), (pos
& 0xffff) != x
) {
551 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos
,x
);
553 if (((pos
+= 16) & 0xffff) == zatm_dev
->mbx_end
[mbx
])
554 pos
= zatm_dev
->mbx_start
[mbx
];
555 cells
= here
[0] & uPD98401_AAL5_SIZE
;
557 printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here
[0],here
[1],here
[2],here
[3]);
560 printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev
,
561 zatm_dev
->pool_base
),
562 zpeekl(zatm_dev
,zatm_dev
->pool_base
+1));
563 x
= (unsigned long *) here
[2];
564 printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
565 x
[0],x
[1],x
[2],x
[3]);
569 if (here
[3] & uPD98401_AAL5_ERR
) {
570 error
= (here
[3] & uPD98401_AAL5_ES
) >>
571 uPD98401_AAL5_ES_SHIFT
;
572 if (error
== uPD98401_AAL5_ES_DEACT
||
573 error
== uPD98401_AAL5_ES_FREE
) continue;
575 EVENT("error code 0x%x/0x%x\n",(here
[3] & uPD98401_AAL5_ES
) >>
576 uPD98401_AAL5_ES_SHIFT
,error
);
577 skb
= ((struct rx_buffer_head
*) bus_to_virt(here
[2]))->skb
;
578 #ifdef CONFIG_ATM_ZATM_EXACT_TS
579 skb
->stamp
= exact_time(zatm_dev
,here
[1]);
584 printk("[-3..0] 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",((unsigned *) skb
->data
)[-3],
585 ((unsigned *) skb
->data
)[-2],((unsigned *) skb
->data
)[-1],
586 ((unsigned *) skb
->data
)[0]);
588 EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb
,
589 (unsigned long) here
);
591 printk("dummy: 0x%08lx, 0x%08lx\n",dummy
[0],dummy
[1]);
593 size
= error
? 0 : ntohs(((u16
*) skb
->data
)[cells
*
594 ATM_CELL_PAYLOAD
/sizeof(u16
)-3]);
595 EVENT("got skb 0x%lx, size %d\n",(unsigned long) skb
,size
);
596 chan
= (here
[3] & uPD98401_AAL5_CHAN
) >>
597 uPD98401_AAL5_CHAN_SHIFT
;
598 if (chan
< zatm_dev
->chans
&& zatm_dev
->rx_map
[chan
]) {
599 vcc
= zatm_dev
->rx_map
[chan
];
600 if (skb
== zatm_dev
->last_free
[ZATM_VCC(vcc
)->pool
])
601 zatm_dev
->last_free
[ZATM_VCC(vcc
)->pool
] = NULL
;
605 printk(KERN_ERR DEV_LABEL
"(itf %d): RX indication "
606 "for non-existing channel\n",dev
->number
);
612 static unsigned long silence
= 0;
613 static int last_error
= 0;
615 if (error
!= last_error
||
616 time_after(jiffies
, silence
) || silence
== 0){
617 printk(KERN_WARNING DEV_LABEL
"(itf %d): "
618 "chan %d error %s\n",dev
->number
,chan
,
621 silence
= (jiffies
+2*HZ
)|1;
625 if (size
&& (size
> cells
*ATM_CELL_PAYLOAD
-ATM_AAL5_TRAILER
||
626 size
<= (cells
-1)*ATM_CELL_PAYLOAD
-ATM_AAL5_TRAILER
)) {
627 printk(KERN_ERR DEV_LABEL
"(itf %d): size %d with %d "
628 "cells\n",dev
->number
,size
,cells
);
632 if (size
> ATM_MAX_AAL5_PDU
) {
633 printk(KERN_ERR DEV_LABEL
"(itf %d): size too big "
634 "(%d)\n",dev
->number
,size
);
640 if (vcc
) vcc
->stats
->rx_err
++;
643 if (!atm_charge(vcc
,skb
->truesize
)) {
648 ATM_SKB(skb
)->vcc
= vcc
;
652 zout(pos
& 0xffff,MTA(mbx
));
653 #if 0 /* probably a stupid idea */
654 refill_pool(dev
,zatm_vcc
->pool
);
655 /* maybe this saves us a few interrupts */
660 static int open_rx_first(struct atm_vcc
*vcc
)
662 struct zatm_dev
*zatm_dev
;
663 struct zatm_vcc
*zatm_vcc
;
668 DPRINTK("open_rx_first (0x%x)\n",inb_p(0xc053));
669 zatm_dev
= ZATM_DEV(vcc
->dev
);
670 zatm_vcc
= ZATM_VCC(vcc
);
671 zatm_vcc
->rx_chan
= 0;
672 if (vcc
->qos
.rxtp
.traffic_class
== ATM_NONE
) return 0;
673 if (vcc
->qos
.aal
== ATM_AAL5
) {
674 if (vcc
->qos
.rxtp
.max_sdu
> 65464)
675 vcc
->qos
.rxtp
.max_sdu
= 65464;
676 /* fix this - we may want to receive 64kB SDUs
678 cells
= (vcc
->qos
.rxtp
.max_sdu
+ATM_AAL5_TRAILER
+
679 ATM_CELL_PAYLOAD
-1)/ATM_CELL_PAYLOAD
;
680 zatm_vcc
->pool
= pool_index(cells
*ATM_CELL_PAYLOAD
);
684 zatm_vcc
->pool
= ZATM_AAL0_POOL
;
686 if (zatm_vcc
->pool
< 0) return -EMSGSIZE
;
690 zout(uPD98401_OPEN_CHAN
,CMR
);
692 DPRINTK("0x%x 0x%x\n",zin(CMR
),zin(CER
));
693 chan
= (zin(CMR
) & uPD98401_CHAN_ADDR
) >> uPD98401_CHAN_ADDR_SHIFT
;
694 restore_flags(flags
);
695 DPRINTK("chan is %d\n",chan
);
696 if (!chan
) return -EAGAIN
;
697 use_pool(vcc
->dev
,zatm_vcc
->pool
);
698 DPRINTK("pool %d\n",zatm_vcc
->pool
);
699 /* set up VC descriptor */
701 zpokel(zatm_dev
,zatm_vcc
->pool
<< uPD98401_RXVC_POOL_SHIFT
,
703 zpokel(zatm_dev
,uPD98401_RXVC_OD
| (vcc
->qos
.aal
== ATM_AAL5
?
704 uPD98401_RXVC_AR
: 0) | cells
,chan
*VC_SIZE
/4+1);
705 zpokel(zatm_dev
,0,chan
*VC_SIZE
/4+2);
706 zatm_vcc
->rx_chan
= chan
;
707 zatm_dev
->rx_map
[chan
] = vcc
;
708 restore_flags(flags
);
713 static int open_rx_second(struct atm_vcc
*vcc
)
715 struct zatm_dev
*zatm_dev
;
716 struct zatm_vcc
*zatm_vcc
;
720 DPRINTK("open_rx_second (0x%x)\n",inb_p(0xc053));
721 zatm_dev
= ZATM_DEV(vcc
->dev
);
722 zatm_vcc
= ZATM_VCC(vcc
);
723 if (!zatm_vcc
->rx_chan
) return 0;
726 /* should also handle VPI @@@ */
728 shift
= (1-(vcc
->vci
& 1)) << 4;
729 zpokel(zatm_dev
,(zpeekl(zatm_dev
,pos
) & ~(0xffff << shift
)) |
730 ((zatm_vcc
->rx_chan
| uPD98401_RXLT_ENBL
) << shift
),pos
);
731 restore_flags(flags
);
732 /* Ugly hack to ensure that ttcp_atm will work with the current allocation
734 if (vcc
->rx_quota
< 200000) vcc
->rx_quota
= 200000;
739 static void close_rx(struct atm_vcc
*vcc
)
741 struct zatm_dev
*zatm_dev
;
742 struct zatm_vcc
*zatm_vcc
;
746 zatm_vcc
= ZATM_VCC(vcc
);
747 zatm_dev
= ZATM_DEV(vcc
->dev
);
748 if (!zatm_vcc
->rx_chan
) return;
749 DPRINTK("close_rx\n");
750 /* disable receiver */
752 if (vcc
->vpi
!= ATM_VPI_UNSPEC
&& vcc
->vci
!= ATM_VCI_UNSPEC
) {
755 shift
= (1-(vcc
->vci
& 1)) << 4;
756 zpokel(zatm_dev
,zpeekl(zatm_dev
,pos
) & ~(0xffff << shift
),pos
);
758 zout(uPD98401_NOP
,CMR
);
760 zout(uPD98401_NOP
,CMR
);
761 restore_flags(flags
);
765 zout(uPD98401_DEACT_CHAN
| uPD98401_CHAN_RT
| (zatm_vcc
->rx_chan
<<
766 uPD98401_CHAN_ADDR_SHIFT
),CMR
);
768 udelay(10); /* why oh why ... ? */
769 zout(uPD98401_CLOSE_CHAN
| uPD98401_CHAN_RT
| (zatm_vcc
->rx_chan
<<
770 uPD98401_CHAN_ADDR_SHIFT
),CMR
);
772 if (!(zin(CMR
) & uPD98401_CHAN_ADDR
))
773 printk(KERN_CRIT DEV_LABEL
"(itf %d): can't close RX channel "
774 "%d\n",vcc
->dev
->number
,zatm_vcc
->rx_chan
);
775 restore_flags(flags
);
776 zatm_dev
->rx_map
[zatm_vcc
->rx_chan
] = NULL
;
777 zatm_vcc
->rx_chan
= 0;
778 unuse_pool(vcc
->dev
,zatm_vcc
->pool
);
782 static int start_rx(struct atm_dev
*dev
)
784 struct zatm_dev
*zatm_dev
;
787 DPRINTK("start_rx\n");
788 zatm_dev
= ZATM_DEV(dev
);
789 size
= sizeof(struct atm_vcc
*)*zatm_dev
->chans
;
790 zatm_dev
->rx_map
= (struct atm_vcc
**) kmalloc(size
,GFP_KERNEL
);
791 if (!zatm_dev
->rx_map
) return -ENOMEM
;
792 memset(zatm_dev
->rx_map
,0,size
);
793 /* set VPI/VCI split (use all VCIs and give what's left to VPIs) */
794 zpokel(zatm_dev
,(1 << dev
->ci_range
.vci_bits
)-1,uPD98401_VRR
);
795 /* prepare free buffer pools */
796 for (i
= 0; i
<= ZATM_LAST_POOL
; i
++) {
797 zatm_dev
->pool_info
[i
].ref_count
= 0;
798 zatm_dev
->pool_info
[i
].rqa_count
= 0;
799 zatm_dev
->pool_info
[i
].rqu_count
= 0;
800 zatm_dev
->pool_info
[i
].low_water
= LOW_MARK
;
801 zatm_dev
->pool_info
[i
].high_water
= HIGH_MARK
;
802 zatm_dev
->pool_info
[i
].offset
= 0;
803 zatm_dev
->pool_info
[i
].next_off
= 0;
804 zatm_dev
->pool_info
[i
].next_cnt
= 0;
805 zatm_dev
->pool_info
[i
].next_thres
= OFF_CNG_THRES
;
811 /*----------------------------------- TX ------------------------------------*/
814 static int do_tx(struct sk_buff
*skb
)
817 struct zatm_dev
*zatm_dev
;
818 struct zatm_vcc
*zatm_vcc
;
822 EVENT("do_tx\n",0,0);
823 DPRINTK("sending skb %p\n",skb
);
824 vcc
= ATM_SKB(skb
)->vcc
;
825 zatm_dev
= ZATM_DEV(vcc
->dev
);
826 zatm_vcc
= ZATM_VCC(vcc
);
827 EVENT("iovcnt=%d\n",ATM_SKB(skb
)->iovcnt
,0);
830 if (!ATM_SKB(skb
)->iovcnt
) {
831 if (zatm_vcc
->txing
== RING_ENTRIES
-1) {
832 restore_flags(flags
);
836 dsc
= zatm_vcc
->ring
+zatm_vcc
->ring_curr
;
837 zatm_vcc
->ring_curr
= (zatm_vcc
->ring_curr
+RING_WORDS
) &
838 (RING_ENTRIES
*RING_WORDS
-1);
841 dsc
[3] = virt_to_bus(skb
->data
);
843 dsc
[0] = uPD98401_TXPD_V
| uPD98401_TXPD_DP
| uPD98401_TXPD_SM
844 | (vcc
->qos
.aal
== ATM_AAL5
? uPD98401_TXPD_AAL5
: 0 |
845 (ATM_SKB(skb
)->atm_options
& ATM_ATMOPT_CLP
?
846 uPD98401_CLPM_1
: uPD98401_CLPM_0
));
847 EVENT("dsc (0x%lx)\n",(unsigned long) dsc
,0);
850 printk("NONONONOO!!!!\n");
856 dsc
= (u32
*) kmalloc(uPD98401_TXPD_SIZE
*2+
857 uPD98401_TXBD_SIZE
*ATM_SKB(skb
)->iovcnt
,GFP_ATOMIC
);
859 if (vcc
->pop
) vcc
->pop(vcc
,skb
);
860 else dev_kfree_skb(skb
);
863 /* @@@ should check alignment */
865 dsc
[0] = uPD98401_TXPD_V
| uPD98401_TXPD_DP
|
866 (vcc
->aal
== ATM_AAL5
? uPD98401_TXPD_AAL5
: 0 |
867 (ATM_SKB(skb
)->atm_options
& ATM_ATMOPT_CLP
?
868 uPD98401_CLPM_1
: uPD98401_CLPM_0
));
870 dsc
[2] = ATM_SKB(skb
)->iovcnt
*uPD98401_TXBD_SIZE
;
871 dsc
[3] = virt_to_bus(put
);
872 for (i
= 0; i
< ATM_SKB(skb
)->iovcnt
; i
++) {
873 *put
++ = ((struct iovec
*) skb
->data
)[i
].iov_len
;
874 *put
++ = virt_to_bus(((struct iovec
*)
875 skb
->data
)[i
].iov_base
);
877 put
[-2] |= uPD98401_TXBD_LAST
;
880 ZATM_PRV_DSC(skb
) = dsc
;
881 skb_queue_tail(&zatm_vcc
->tx_queue
,skb
);
882 DPRINTK("QRP=0x%08lx\n",zpeekl(zatm_dev
,zatm_vcc
->tx_chan
*VC_SIZE
/4+
885 zout(uPD98401_TX_READY
| (zatm_vcc
->tx_chan
<<
886 uPD98401_CHAN_ADDR_SHIFT
),CMR
);
887 restore_flags(flags
);
893 static inline void dequeue_tx(struct atm_vcc
*vcc
)
895 struct zatm_vcc
*zatm_vcc
;
898 EVENT("dequeue_tx\n",0,0);
899 zatm_vcc
= ZATM_VCC(vcc
);
900 skb
= skb_dequeue(&zatm_vcc
->tx_queue
);
902 printk(KERN_CRIT DEV_LABEL
"(itf %d): dequeue_tx but not "
903 "txing\n",vcc
->dev
->number
);
906 #if 0 /* @@@ would fail on CLP */
907 if (*ZATM_PRV_DSC(skb
) != (uPD98401_TXPD_V
| uPD98401_TXPD_DP
|
908 uPD98401_TXPD_SM
| uPD98401_TXPD_AAL5
)) printk("@#*$!!!! (%08x)\n",
911 *ZATM_PRV_DSC(skb
) = 0; /* mark as invalid */
913 if (vcc
->pop
) vcc
->pop(vcc
,skb
);
914 else dev_kfree_skb(skb
);
915 while ((skb
= skb_dequeue(&zatm_vcc
->backlog
)))
916 if (do_tx(skb
) == RING_BUSY
) {
917 skb_queue_head(&zatm_vcc
->backlog
,skb
);
921 wake_up(&zatm_vcc
->tx_wait
);
925 static void poll_tx(struct atm_dev
*dev
,int mbx
)
927 struct zatm_dev
*zatm_dev
;
931 EVENT("poll_tx\n",0,0);
932 zatm_dev
= ZATM_DEV(dev
);
933 pos
= (zatm_dev
->mbx_start
[mbx
] & ~0xffffUL
) | zin(MTA(mbx
));
934 while (x
= zin(MWA(mbx
)), (pos
& 0xffff) != x
) {
940 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos
,x
);
943 chan
= (data
& uPD98401_TXI_CONN
) >> uPD98401_TXI_CONN_SHIFT
;
944 EVENT("addr = 0x%lx, data = 0x%08x,",(unsigned long) addr
,
946 EVENT("chan = %d\n",chan
,0);
949 chan
= (zatm_dev
->mbx_start
[mbx
][pos
>> 2] & uPD98401_TXI_CONN
)
950 >> uPD98401_TXI_CONN_SHIFT
;
952 if (chan
< zatm_dev
->chans
&& zatm_dev
->tx_map
[chan
])
953 dequeue_tx(zatm_dev
->tx_map
[chan
]);
955 printk(KERN_CRIT DEV_LABEL
"(itf %d): TX indication "
956 "for non-existing channel %d\n",dev
->number
,chan
);
959 if (((pos
+= 4) & 0xffff) == zatm_dev
->mbx_end
[mbx
])
960 pos
= zatm_dev
->mbx_start
[mbx
];
962 zout(pos
& 0xffff,MTA(mbx
));
967 * BUG BUG BUG: Doesn't handle "new-style" rate specification yet.
970 static int alloc_shaper(struct atm_dev
*dev
,int *pcr
,int min
,int max
,int ubr
)
972 struct zatm_dev
*zatm_dev
;
977 DPRINTK("alloc_shaper (min = %d, max = %d)\n",min
,max
);
978 zatm_dev
= ZATM_DEV(dev
);
979 if (!zatm_dev
->free_shapers
) return -EAGAIN
;
980 for (shaper
= 0; !((zatm_dev
->free_shapers
>> shaper
) & 1); shaper
++);
981 zatm_dev
->free_shapers
&= ~1 << shaper
;
985 zatm_dev
->ubr_ref_cnt
++;
986 zatm_dev
->ubr
= shaper
;
996 m
= ATM_OC3_PCR
*255/min
;
1000 if (max
> zatm_dev
->tx_bw
) max
= zatm_dev
->tx_bw
;
1007 m
= (ATM_OC3_PCR
*255+max
-1)/max
;
1011 printk(KERN_CRIT DEV_LABEL
"shaper algorithm botched "
1012 "[%d,%d] -> i=%ld,m=%ld\n",min
,max
,i
,m
);
1015 *pcr
= i
*ATM_OC3_PCR
/m
;
1016 c
= 20; /* @@@ should use max_cdv ! */
1017 if ((min
&& *pcr
< min
) || (max
&& *pcr
> max
)) return -EINVAL
;
1018 if (zatm_dev
->tx_bw
< *pcr
) return -EAGAIN
;
1019 zatm_dev
->tx_bw
-= *pcr
;
1023 DPRINTK("i = %d, m = %d, PCR = %d\n",i
,m
,*pcr
);
1024 zpokel(zatm_dev
,(i
<< uPD98401_IM_I_SHIFT
) | m
,uPD98401_IM(shaper
));
1025 zpokel(zatm_dev
,c
<< uPD98401_PC_C_SHIFT
,uPD98401_PC(shaper
));
1026 zpokel(zatm_dev
,0,uPD98401_X(shaper
));
1027 zpokel(zatm_dev
,0,uPD98401_Y(shaper
));
1028 zpokel(zatm_dev
,uPD98401_PS_E
,uPD98401_PS(shaper
));
1029 restore_flags(flags
);
1034 static void dealloc_shaper(struct atm_dev
*dev
,int shaper
)
1036 struct zatm_dev
*zatm_dev
;
1037 unsigned long flags
;
1039 zatm_dev
= ZATM_DEV(dev
);
1040 if (shaper
== zatm_dev
->ubr
) {
1041 if (--zatm_dev
->ubr_ref_cnt
) return;
1046 zpokel(zatm_dev
,zpeekl(zatm_dev
,uPD98401_PS(shaper
)) & ~uPD98401_PS_E
,
1047 uPD98401_PS(shaper
));
1048 restore_flags(flags
);
1049 zatm_dev
->free_shapers
|= 1 << shaper
;
1053 static void close_tx(struct atm_vcc
*vcc
)
1055 struct zatm_dev
*zatm_dev
;
1056 struct zatm_vcc
*zatm_vcc
;
1057 unsigned long flags
;
1059 struct sk_buff
*skb
;
1062 zatm_vcc
= ZATM_VCC(vcc
);
1063 zatm_dev
= ZATM_DEV(vcc
->dev
);
1064 chan
= zatm_vcc
->tx_chan
;
1066 DPRINTK("close_tx\n");
1069 while (skb_peek(&zatm_vcc
->backlog
)) {
1071 printk("waiting for backlog to drain ...\n");
1075 sleep_on(&zatm_vcc
->tx_wait
);
1078 while ((skb
= skb_peek(&zatm_vcc
->tx_queue
))) {
1080 printk("waiting for TX queue to drain ... %p\n",skb
);
1084 DPRINTK("waiting for TX queue to drain ... %p\n",skb
);
1085 sleep_on(&zatm_vcc
->tx_wait
);
1089 zout(uPD98401_DEACT_CHAN
| (chan
<< uPD98401_CHAN_ADDR_SHIFT
),CMR
);
1092 zout(uPD98401_CLOSE_CHAN
| (chan
<< uPD98401_CHAN_ADDR_SHIFT
),CMR
);
1094 if (!(zin(CMR
) & uPD98401_CHAN_ADDR
))
1095 printk(KERN_CRIT DEV_LABEL
"(itf %d): can't close TX channel "
1096 "%d\n",vcc
->dev
->number
,chan
);
1097 restore_flags(flags
);
1098 zatm_vcc
->tx_chan
= 0;
1099 zatm_dev
->tx_map
[chan
] = NULL
;
1100 if (zatm_vcc
->shaper
!= zatm_dev
->ubr
) {
1101 zatm_dev
->tx_bw
+= vcc
->qos
.txtp
.min_pcr
;
1102 dealloc_shaper(vcc
->dev
,zatm_vcc
->shaper
);
1104 if (zatm_vcc
->ring
) kfree(zatm_vcc
->ring
);
1108 static int open_tx_first(struct atm_vcc
*vcc
)
1110 struct zatm_dev
*zatm_dev
;
1111 struct zatm_vcc
*zatm_vcc
;
1112 unsigned long flags
;
1114 unsigned short chan
;
1117 DPRINTK("open_tx_first\n");
1118 zatm_dev
= ZATM_DEV(vcc
->dev
);
1119 zatm_vcc
= ZATM_VCC(vcc
);
1120 zatm_vcc
->tx_chan
= 0;
1121 if (vcc
->qos
.txtp
.traffic_class
== ATM_NONE
) return 0;
1125 zout(uPD98401_OPEN_CHAN
,CMR
);
1127 DPRINTK("0x%x 0x%x\n",zin(CMR
),zin(CER
));
1128 chan
= (zin(CMR
) & uPD98401_CHAN_ADDR
) >> uPD98401_CHAN_ADDR_SHIFT
;
1129 restore_flags(flags
);
1130 DPRINTK("chan is %d\n",chan
);
1131 if (!chan
) return -EAGAIN
;
1132 unlimited
= vcc
->qos
.txtp
.traffic_class
== ATM_UBR
&&
1133 (!vcc
->qos
.txtp
.max_pcr
|| vcc
->qos
.txtp
.max_pcr
== ATM_MAX_PCR
||
1134 vcc
->qos
.txtp
.max_pcr
>= ATM_OC3_PCR
);
1135 if (unlimited
&& zatm_dev
->ubr
!= -1) zatm_vcc
->shaper
= zatm_dev
->ubr
;
1137 if (unlimited
) vcc
->qos
.txtp
.max_sdu
= ATM_MAX_AAL5_PDU
;
1138 if ((zatm_vcc
->shaper
= alloc_shaper(vcc
->dev
,&pcr
,
1139 vcc
->qos
.txtp
.min_pcr
,vcc
->qos
.txtp
.max_pcr
,unlimited
))
1142 return zatm_vcc
->shaper
;
1144 if (pcr
> ATM_OC3_PCR
) pcr
= ATM_OC3_PCR
;
1145 vcc
->qos
.txtp
.min_pcr
= vcc
->qos
.txtp
.max_pcr
= pcr
;
1147 zatm_vcc
->tx_chan
= chan
;
1148 skb_queue_head_init(&zatm_vcc
->tx_queue
);
1149 init_waitqueue_head(&zatm_vcc
->tx_wait
);
1150 /* initialize ring */
1151 zatm_vcc
->ring
= kmalloc(RING_SIZE
,GFP_KERNEL
);
1152 if (!zatm_vcc
->ring
) return -ENOMEM
;
1153 memset(zatm_vcc
->ring
,0,RING_SIZE
);
1154 loop
= zatm_vcc
->ring
+RING_ENTRIES
*RING_WORDS
;
1155 loop
[0] = uPD98401_TXPD_V
;
1156 loop
[1] = loop
[2] = 0;
1157 loop
[3] = virt_to_bus(zatm_vcc
->ring
);
1158 zatm_vcc
->ring_curr
= 0;
1159 zatm_vcc
->txing
= 0;
1160 skb_queue_head_init(&zatm_vcc
->backlog
);
1161 zpokel(zatm_dev
,virt_to_bus(zatm_vcc
->ring
),
1162 chan
*VC_SIZE
/4+uPD98401_TXVC_QRP
);
1167 static int open_tx_second(struct atm_vcc
*vcc
)
1169 struct zatm_dev
*zatm_dev
;
1170 struct zatm_vcc
*zatm_vcc
;
1171 unsigned long flags
;
1173 DPRINTK("open_tx_second\n");
1174 zatm_dev
= ZATM_DEV(vcc
->dev
);
1175 zatm_vcc
= ZATM_VCC(vcc
);
1176 if (!zatm_vcc
->tx_chan
) return 0;
1178 /* set up VC descriptor */
1180 zpokel(zatm_dev
,0,zatm_vcc
->tx_chan
*VC_SIZE
/4);
1181 zpokel(zatm_dev
,uPD98401_TXVC_L
| (zatm_vcc
->shaper
<<
1182 uPD98401_TXVC_SHP_SHIFT
) | (vcc
->vpi
<< uPD98401_TXVC_VPI_SHIFT
) |
1183 vcc
->vci
,zatm_vcc
->tx_chan
*VC_SIZE
/4+1);
1184 zpokel(zatm_dev
,0,zatm_vcc
->tx_chan
*VC_SIZE
/4+2);
1185 restore_flags(flags
);
1186 zatm_dev
->tx_map
[zatm_vcc
->tx_chan
] = vcc
;
1191 static int start_tx(struct atm_dev
*dev
)
1193 struct zatm_dev
*zatm_dev
;
1196 DPRINTK("start_tx\n");
1197 zatm_dev
= ZATM_DEV(dev
);
1198 zatm_dev
->tx_map
= (struct atm_vcc
**) kmalloc(sizeof(struct atm_vcc
*)*
1199 zatm_dev
->chans
,GFP_KERNEL
);
1200 if (!zatm_dev
->tx_map
) return -ENOMEM
;
1201 zatm_dev
->tx_bw
= ATM_OC3_PCR
;
1202 zatm_dev
->free_shapers
= (1 << NR_SHAPERS
)-1;
1204 zatm_dev
->ubr_ref_cnt
= 0;
1205 /* initialize shapers */
1206 for (i
= 0; i
< NR_SHAPERS
; i
++) zpokel(zatm_dev
,0,uPD98401_PS(i
));
1211 /*------------------------------- interrupts --------------------------------*/
1214 static void zatm_int(int irq
,void *dev_id
,struct pt_regs
*regs
)
1216 struct atm_dev
*dev
;
1217 struct zatm_dev
*zatm_dev
;
1221 zatm_dev
= ZATM_DEV(dev
);
1222 while ((reason
= zin(GSR
))) {
1223 EVENT("reason 0x%x\n",reason
,0);
1224 if (reason
& uPD98401_INT_PI
) {
1225 EVENT("PHY int\n",0,0);
1226 dev
->phy
->interrupt(dev
);
1228 if (reason
& uPD98401_INT_RQA
) {
1229 unsigned long pools
;
1233 EVENT("RQA (0x%08x)\n",pools
,0);
1234 for (i
= 0; pools
; i
++) {
1237 zatm_dev
->pool_info
[i
].rqa_count
++;
1242 if (reason
& uPD98401_INT_RQU
) {
1243 unsigned long pools
;
1246 printk(KERN_WARNING DEV_LABEL
"(itf %d): RQU 0x%08lx\n",
1249 for (i
= 0; pools
; i
++) {
1252 zatm_dev
->pool_info
[i
].rqu_count
++;
1257 /* don't handle RD */
1258 if (reason
& uPD98401_INT_SPE
)
1259 printk(KERN_ALERT DEV_LABEL
"(itf %d): system parity "
1260 "error at 0x%08x\n",dev
->number
,zin(ADDR
));
1261 if (reason
& uPD98401_INT_CPE
)
1262 printk(KERN_ALERT DEV_LABEL
"(itf %d): control memory "
1263 "parity error at 0x%08x\n",dev
->number
,zin(ADDR
));
1264 if (reason
& uPD98401_INT_SBE
) {
1265 printk(KERN_ALERT DEV_LABEL
"(itf %d): system bus "
1266 "error at 0x%08x\n",dev
->number
,zin(ADDR
));
1269 /* don't handle IND */
1270 if (reason
& uPD98401_INT_MF
) {
1271 printk(KERN_CRIT DEV_LABEL
"(itf %d): mailbox full "
1272 "(0x%x)\n",dev
->number
,(reason
& uPD98401_INT_MF
)
1273 >> uPD98401_INT_MF_SHIFT
);
1275 /* @@@ should try to recover */
1277 if (reason
& uPD98401_INT_MM
) {
1278 if (reason
& 1) poll_rx(dev
,0);
1279 if (reason
& 2) poll_rx(dev
,1);
1280 if (reason
& 4) poll_tx(dev
,2);
1281 if (reason
& 8) poll_tx(dev
,3);
1283 /* @@@ handle RCRn */
1288 /*----------------------------- (E)EPROM access -----------------------------*/
1291 static void __init
eprom_set(struct zatm_dev
*zatm_dev
,unsigned long value
,
1296 if ((error
= pci_write_config_dword(zatm_dev
->pci_dev
,cmd
,value
)))
1297 printk(KERN_ERR DEV_LABEL
": PCI write failed (0x%02x)\n",
1302 static unsigned long __init
eprom_get(struct zatm_dev
*zatm_dev
,
1308 if ((error
= pci_read_config_dword(zatm_dev
->pci_dev
,cmd
,&value
)))
1309 printk(KERN_ERR DEV_LABEL
": PCI read failed (0x%02x)\n",
1315 static void __init
eprom_put_bits(struct zatm_dev
*zatm_dev
,
1316 unsigned long data
,int bits
,unsigned short cmd
)
1318 unsigned long value
;
1321 for (i
= bits
-1; i
>= 0; i
--) {
1322 value
= ZEPROM_CS
| (((data
>> i
) & 1) ? ZEPROM_DI
: 0);
1323 eprom_set(zatm_dev
,value
,cmd
);
1324 eprom_set(zatm_dev
,value
| ZEPROM_SK
,cmd
);
1325 eprom_set(zatm_dev
,value
,cmd
);
1330 static void __init
eprom_get_byte(struct zatm_dev
*zatm_dev
,
1331 unsigned char *byte
,unsigned short cmd
)
1336 for (i
= 8; i
; i
--) {
1337 eprom_set(zatm_dev
,ZEPROM_CS
,cmd
);
1338 eprom_set(zatm_dev
,ZEPROM_CS
| ZEPROM_SK
,cmd
);
1340 if (eprom_get(zatm_dev
,cmd
) & ZEPROM_DO
) *byte
|= 1;
1341 eprom_set(zatm_dev
,ZEPROM_CS
,cmd
);
1346 static unsigned char __init
eprom_try_esi(struct atm_dev
*dev
,
1347 unsigned short cmd
,int offset
,int swap
)
1349 unsigned char buf
[ZEPROM_SIZE
];
1350 struct zatm_dev
*zatm_dev
;
1353 zatm_dev
= ZATM_DEV(dev
);
1354 for (i
= 0; i
< ZEPROM_SIZE
; i
+= 2) {
1355 eprom_set(zatm_dev
,ZEPROM_CS
,cmd
); /* select EPROM */
1356 eprom_put_bits(zatm_dev
,ZEPROM_CMD_READ
,ZEPROM_CMD_LEN
,cmd
);
1357 eprom_put_bits(zatm_dev
,i
>> 1,ZEPROM_ADDR_LEN
,cmd
);
1358 eprom_get_byte(zatm_dev
,buf
+i
+swap
,cmd
);
1359 eprom_get_byte(zatm_dev
,buf
+i
+1-swap
,cmd
);
1360 eprom_set(zatm_dev
,0,cmd
); /* deselect EPROM */
1362 memcpy(dev
->esi
,buf
+offset
,ESI_LEN
);
1363 return memcmp(dev
->esi
,"\0\0\0\0\0",ESI_LEN
); /* assumes ESI_LEN == 6 */
1367 static void __init
eprom_get_esi(struct atm_dev
*dev
)
1369 if (eprom_try_esi(dev
,ZEPROM_V1_REG
,ZEPROM_V1_ESI_OFF
,1)) return;
1370 (void) eprom_try_esi(dev
,ZEPROM_V2_REG
,ZEPROM_V2_ESI_OFF
,0);
1374 /*--------------------------------- entries ---------------------------------*/
1377 static int __init
zatm_init(struct atm_dev
*dev
)
1379 struct zatm_dev
*zatm_dev
;
1380 struct pci_dev
*pci_dev
;
1381 unsigned short command
;
1382 unsigned char revision
;
1384 unsigned long t0
,t1
,t2
;
1386 DPRINTK(">zatm_init\n");
1387 zatm_dev
= ZATM_DEV(dev
);
1388 pci_dev
= zatm_dev
->pci_dev
;
1389 zatm_dev
->base
= pci_dev
->resource
[0].start
;
1390 zatm_dev
->irq
= pci_dev
->irq
;
1391 if ((error
= pci_read_config_word(pci_dev
,PCI_COMMAND
,&command
)) ||
1392 (error
= pci_read_config_byte(pci_dev
,PCI_REVISION_ID
,&revision
))) {
1393 printk(KERN_ERR DEV_LABEL
"(itf %d): init error 0x%02x\n",
1397 if ((error
= pci_write_config_word(pci_dev
,PCI_COMMAND
,
1398 command
| PCI_COMMAND_IO
| PCI_COMMAND_MASTER
))) {
1399 printk(KERN_ERR DEV_LABEL
"(itf %d): can't enable IO (0x%02x)"
1400 "\n",dev
->number
,error
);
1404 printk(KERN_NOTICE DEV_LABEL
"(itf %d): rev.%d,base=0x%x,irq=%d,",
1405 dev
->number
,revision
,zatm_dev
->base
,zatm_dev
->irq
);
1406 /* reset uPD98401 */
1408 while (!(zin(GSR
) & uPD98401_INT_IND
));
1409 zout(uPD98401_GMR_ONE
/*uPD98401_BURST4*/,GMR
);
1410 last
= MAX_CRAM_SIZE
;
1411 for (i
= last
-RAM_INCREMENT
; i
>= 0; i
-= RAM_INCREMENT
) {
1412 zpokel(zatm_dev
,0x55555555,i
);
1413 if (zpeekl(zatm_dev
,i
) != 0x55555555) last
= i
;
1415 zpokel(zatm_dev
,0xAAAAAAAA,i
);
1416 if (zpeekl(zatm_dev
,i
) != 0xAAAAAAAA) last
= i
;
1417 else zpokel(zatm_dev
,i
,i
);
1420 for (i
= 0; i
< last
; i
+= RAM_INCREMENT
)
1421 if (zpeekl(zatm_dev
,i
) != i
) break;
1422 zatm_dev
->mem
= i
<< 2;
1423 while (i
) zpokel(zatm_dev
,0,--i
);
1424 /* reset again to rebuild memory pointers */
1426 while (!(zin(GSR
) & uPD98401_INT_IND
));
1427 zout(uPD98401_GMR_ONE
| uPD98401_BURST8
| uPD98401_BURST4
|
1428 uPD98401_BURST2
| uPD98401_GMR_PM
| uPD98401_GMR_DR
,GMR
);
1429 /* TODO: should shrink allocation now */
1430 printk("mem=%dkB,%s (",zatm_dev
->mem
>> 10,zatm_dev
->copper
? "UTP" :
1432 for (i
= 0; i
< ESI_LEN
; i
++)
1433 printk("%02X%s",dev
->esi
[i
],i
== ESI_LEN
-1 ? ")\n" : "-");
1435 unsigned long flags
;
1439 t0
= zpeekl(zatm_dev
,uPD98401_TSR
);
1441 t1
= zpeekl(zatm_dev
,uPD98401_TSR
);
1443 t2
= zpeekl(zatm_dev
,uPD98401_TSR
);
1444 restore_flags(flags
);
1446 while (t0
> t1
|| t1
> t2
); /* loop if wrapping ... */
1447 zatm_dev
->khz
= t2
-2*t1
+t0
;
1448 printk(KERN_NOTICE DEV_LABEL
"(itf %d): uPD98401 %d.%d at %d.%03d "
1449 "MHz\n",dev
->number
,
1450 (zin(VER
) & uPD98401_MAJOR
) >> uPD98401_MAJOR_SHIFT
,
1451 zin(VER
) & uPD98401_MINOR
,zatm_dev
->khz
/1000,zatm_dev
->khz
% 1000);
1452 #ifdef CONFIG_ATM_ZATM_EXACT_TS
1453 zatm_clock_init(zatm_dev
);
1455 return uPD98402_init(dev
);
1459 static int __init
zatm_start(struct atm_dev
*dev
)
1461 struct zatm_dev
*zatm_dev
;
1466 DPRINTK("zatm_start\n");
1467 zatm_dev
= ZATM_DEV(dev
);
1468 if (request_irq(zatm_dev
->irq
,&zatm_int
,SA_SHIRQ
,DEV_LABEL
,dev
)) {
1469 printk(KERN_ERR DEV_LABEL
"(itf %d): IRQ%d is already in use\n",
1470 dev
->number
,zatm_dev
->irq
);
1473 request_region(zatm_dev
->base
,uPD98401_PORTS
,DEV_LABEL
);
1474 /* define memory regions */
1476 if (NR_SHAPERS
*SHAPER_SIZE
> pools
*POOL_SIZE
)
1477 pools
= NR_SHAPERS
*SHAPER_SIZE
/POOL_SIZE
;
1478 vccs
= (zatm_dev
->mem
-NR_SHAPERS
*SHAPER_SIZE
-pools
*POOL_SIZE
)/
1479 (2*VC_SIZE
+RX_SIZE
);
1481 for (rx
= 1; rx
< vccs
; rx
<<= 1) ld
++;
1482 dev
->ci_range
.vpi_bits
= 0; /* @@@ no VPI for now */
1483 dev
->ci_range
.vci_bits
= ld
;
1484 dev
->link_rate
= ATM_OC3_PCR
;
1485 zatm_dev
->chans
= vccs
; /* ??? */
1486 curr
= rx
*RX_SIZE
/4;
1487 DPRINTK("RX pool 0x%08lx\n",curr
);
1488 zpokel(zatm_dev
,curr
,uPD98401_PMA
); /* receive pool */
1489 zatm_dev
->pool_base
= curr
;
1490 curr
+= pools
*POOL_SIZE
/4;
1491 DPRINTK("Shapers 0x%08lx\n",curr
);
1492 zpokel(zatm_dev
,curr
,uPD98401_SMA
); /* shapers */
1493 curr
+= NR_SHAPERS
*SHAPER_SIZE
/4;
1494 DPRINTK("Free 0x%08lx\n",curr
);
1495 zpokel(zatm_dev
,curr
,uPD98401_TOS
); /* free pool */
1496 printk(KERN_INFO DEV_LABEL
"(itf %d): %d shapers, %d pools, %d RX, "
1497 "%ld VCs\n",dev
->number
,NR_SHAPERS
,pools
,rx
,
1498 (zatm_dev
->mem
-curr
*4)/VC_SIZE
);
1499 /* create mailboxes */
1500 for (i
= 0; i
< NR_MBX
; i
++) zatm_dev
->mbx_start
[i
] = 0;
1501 for (i
= 0; i
< NR_MBX
; i
++)
1502 if (mbx_entries
[i
]) {
1505 here
= (unsigned long) kmalloc(2*MBX_SIZE(i
),
1507 if (!here
) return -ENOMEM
;
1508 if ((here
^(here
+MBX_SIZE(i
))) & ~0xffffUL
)/* paranoia */
1509 here
= (here
& ~0xffffUL
)+0x10000;
1510 if ((here
^virt_to_bus((void *) here
)) & 0xffff) {
1511 printk(KERN_ERR DEV_LABEL
"(itf %d): system "
1512 "bus incompatible with driver\n",
1514 kfree((void *) here
);
1517 DPRINTK("mbx@0x%08lx-0x%08lx\n",here
,here
+MBX_SIZE(i
));
1518 zatm_dev
->mbx_start
[i
] = here
;
1519 zatm_dev
->mbx_end
[i
] = (here
+MBX_SIZE(i
)) & 0xffff;
1520 zout(virt_to_bus((void *) here
) >> 16,MSH(i
));
1521 zout(virt_to_bus((void *) here
),MSL(i
));
1522 zout((here
+MBX_SIZE(i
)) & 0xffff,MBA(i
));
1523 zout(here
& 0xffff,MTA(i
));
1524 zout(here
& 0xffff,MWA(i
));
1526 error
= start_tx(dev
);
1527 if (error
) return error
;
1528 error
= start_rx(dev
);
1529 if (error
) return error
;
1530 error
= dev
->phy
->start(dev
);
1531 if (error
) return error
;
1532 zout(0xffffffff,IMR
); /* enable interrupts */
1533 /* enable TX & RX */
1534 zout(zin(GMR
) | uPD98401_GMR_SE
| uPD98401_GMR_RE
,GMR
);
1539 static void zatm_close(struct atm_vcc
*vcc
)
1541 DPRINTK(">zatm_close\n");
1542 if (!ZATM_VCC(vcc
)) return;
1543 vcc
->flags
&= ~ATM_VF_READY
;
1545 EVENT("close_tx\n",0,0);
1547 DPRINTK("zatm_close: done waiting\n");
1548 /* deallocate memory */
1549 kfree(ZATM_VCC(vcc
));
1550 ZATM_VCC(vcc
) = NULL
;
1551 vcc
->flags
&= ~ATM_VF_ADDR
;
1555 static int zatm_open(struct atm_vcc
*vcc
,short vpi
,int vci
)
1557 struct zatm_dev
*zatm_dev
;
1558 struct zatm_vcc
*zatm_vcc
;
1561 DPRINTK(">zatm_open\n");
1562 zatm_dev
= ZATM_DEV(vcc
->dev
);
1563 if (!(vcc
->flags
& ATM_VF_PARTIAL
)) ZATM_VCC(vcc
) = NULL
;
1564 error
= atm_find_ci(vcc
,&vpi
,&vci
);
1565 if (error
) return error
;
1568 if (vci
!= ATM_VPI_UNSPEC
&& vpi
!= ATM_VCI_UNSPEC
)
1569 vcc
->flags
|= ATM_VF_ADDR
;
1570 if (vcc
->qos
.aal
!= ATM_AAL5
) return -EINVAL
; /* @@@ AAL0 */
1571 DPRINTK(DEV_LABEL
"(itf %d): open %d.%d\n",vcc
->dev
->number
,vcc
->vpi
,
1573 if (!(vcc
->flags
& ATM_VF_PARTIAL
)) {
1574 zatm_vcc
= kmalloc(sizeof(struct zatm_vcc
),GFP_KERNEL
);
1576 vcc
->flags
&= ~ATM_VF_ADDR
;
1579 ZATM_VCC(vcc
) = zatm_vcc
;
1580 ZATM_VCC(vcc
)->tx_chan
= 0; /* for zatm_close after open_rx */
1581 if ((error
= open_rx_first(vcc
))) {
1585 if ((error
= open_tx_first(vcc
))) {
1590 if (vci
== ATM_VPI_UNSPEC
|| vpi
== ATM_VCI_UNSPEC
) return 0;
1591 if ((error
= open_rx_second(vcc
))) {
1595 if ((error
= open_tx_second(vcc
))) {
1599 vcc
->flags
|= ATM_VF_READY
;
1604 static int zatm_change_qos(struct atm_vcc
*vcc
,struct atm_qos
*qos
,int flags
)
1606 printk("Not yet implemented\n");
1612 static int zatm_ioctl(struct atm_dev
*dev
,unsigned int cmd
,void *arg
)
1614 struct zatm_dev
*zatm_dev
;
1615 unsigned long flags
;
1617 zatm_dev
= ZATM_DEV(dev
);
1620 if (!capable(CAP_NET_ADMIN
)) return -EPERM
;
1624 struct zatm_pool_info info
;
1628 &((struct zatm_pool_req
*) arg
)->pool_num
))
1630 if (pool
< 0 || pool
> ZATM_LAST_POOL
)
1634 info
= zatm_dev
->pool_info
[pool
];
1635 if (cmd
== ZATM_GETPOOLZ
) {
1636 zatm_dev
->pool_info
[pool
].rqa_count
= 0;
1637 zatm_dev
->pool_info
[pool
].rqu_count
= 0;
1639 restore_flags(flags
);
1640 return copy_to_user(
1641 &((struct zatm_pool_req
*) arg
)->info
,
1642 &info
,sizeof(info
)) ? -EFAULT
: 0;
1646 struct zatm_pool_info info
;
1649 if (!capable(CAP_NET_ADMIN
)) return -EPERM
;
1651 &((struct zatm_pool_req
*) arg
)->pool_num
))
1653 if (pool
< 0 || pool
> ZATM_LAST_POOL
)
1655 if (copy_from_user(&info
,
1656 &((struct zatm_pool_req
*) arg
)->info
,
1657 sizeof(info
))) return -EFAULT
;
1658 if (!info
.low_water
)
1659 info
.low_water
= zatm_dev
->
1660 pool_info
[pool
].low_water
;
1661 if (!info
.high_water
)
1662 info
.high_water
= zatm_dev
->
1663 pool_info
[pool
].high_water
;
1664 if (!info
.next_thres
)
1665 info
.next_thres
= zatm_dev
->
1666 pool_info
[pool
].next_thres
;
1667 if (info
.low_water
>= info
.high_water
||
1672 zatm_dev
->pool_info
[pool
].low_water
=
1674 zatm_dev
->pool_info
[pool
].high_water
=
1676 zatm_dev
->pool_info
[pool
].next_thres
=
1678 restore_flags(flags
);
1681 #ifdef CONFIG_ATM_ZATM_EXACT_TS
1688 for (i
= 0; i
< ZATM_TIMER_HISTORY_SIZE
; i
++) {
1690 (struct zatm_t_hist
*) arg
+i
,
1691 &zatm_dev
->timer_history
[
1692 (zatm_dev
->th_curr
+i
) &
1693 (ZATM_TIMER_HISTORY_SIZE
-1)],
1694 sizeof(struct zatm_t_hist
)))
1696 restore_flags(flags
);
1699 restore_flags(flags
);
1704 if (!dev
->phy
->ioctl
) return -EINVAL
;
1705 return dev
->phy
->ioctl(dev
,cmd
,arg
);
1710 static int zatm_getsockopt(struct atm_vcc
*vcc
,int level
,int optname
,
1711 void *optval
,int optlen
)
1713 #ifdef CONFIG_MMU_HACKS
1715 static const struct atm_buffconst bctx
= { PAGE_SIZE
,0,PAGE_SIZE
,0,0,0 };
1716 static const struct atm_buffconst bcrx
= { PAGE_SIZE
,0,PAGE_SIZE
,0,0,0 };
1720 static const struct atm_buffconst bctx
= { 4,0,4,0,0,0 };
1721 static const struct atm_buffconst bcrx
= { 4,0,4,0,0,0 };
1724 if (level
== SOL_AAL
&& (optname
== SO_BCTXOPT
||
1725 optname
== SO_BCRXOPT
))
1726 return copy_to_user(optval
,optname
== SO_BCTXOPT
? &bctx
:
1727 &bcrx
,sizeof(struct atm_buffconst
)) ? -EFAULT
: 0;
1732 static int zatm_setsockopt(struct atm_vcc
*vcc
,int level
,int optname
,
1733 void *optval
,int optlen
)
1740 static int zatm_sg_send(struct atm_vcc
*vcc
,unsigned long start
,
1743 return vcc
->aal
== ATM_AAL5
;
1744 /* @@@ should check size and maybe alignment*/
1749 static int zatm_send(struct atm_vcc
*vcc
,struct sk_buff
*skb
)
1753 EVENT(">zatm_send 0x%lx\n",(unsigned long) skb
,0);
1754 if (!ZATM_VCC(vcc
)->tx_chan
|| !(vcc
->flags
& ATM_VF_READY
)) {
1755 if (vcc
->pop
) vcc
->pop(vcc
,skb
);
1756 else dev_kfree_skb(skb
);
1760 printk(KERN_CRIT
"!skb in zatm_send ?\n");
1761 if (vcc
->pop
) vcc
->pop(vcc
,skb
);
1762 else dev_kfree_skb(skb
);
1765 ATM_SKB(skb
)->vcc
= vcc
;
1767 if (error
!= RING_BUSY
) return error
;
1768 skb_queue_tail(&ZATM_VCC(vcc
)->backlog
,skb
);
1773 static void zatm_phy_put(struct atm_dev
*dev
,unsigned char value
,
1776 struct zatm_dev
*zatm_dev
;
1778 zatm_dev
= ZATM_DEV(dev
);
1781 zout(uPD98401_IND_ACC
| uPD98401_IA_B0
|
1782 (uPD98401_IA_TGT_PHY
<< uPD98401_IA_TGT_SHIFT
) | addr
,CMR
);
1786 static unsigned char zatm_phy_get(struct atm_dev
*dev
,unsigned long addr
)
1788 struct zatm_dev
*zatm_dev
;
1790 zatm_dev
= ZATM_DEV(dev
);
1792 zout(uPD98401_IND_ACC
| uPD98401_IA_B0
| uPD98401_IA_RW
|
1793 (uPD98401_IA_TGT_PHY
<< uPD98401_IA_TGT_SHIFT
) | addr
,CMR
);
1795 return zin(CER
) & 0xff;
1799 static const struct atmdev_ops ops
= {
1800 NULL
, /* no dev_close */
1807 NULL
/*zatm_sg_send*/,
1808 NULL
, /* no send_oam */
1813 NULL
, /* no free_rx_skb */
1814 NULL
/* no proc_read */
1818 int __init
zatm_detect(void)
1820 struct atm_dev
*dev
;
1821 struct zatm_dev
*zatm_dev
;
1824 zatm_dev
= (struct zatm_dev
*) kmalloc(sizeof(struct zatm_dev
),
1826 if (!zatm_dev
) return -ENOMEM
;
1828 for (type
= 0; type
< 2; type
++) {
1829 struct pci_dev
*pci_dev
;
1832 while ((pci_dev
= pci_find_device(PCI_VENDOR_ID_ZEITNET
,type
?
1833 PCI_DEVICE_ID_ZEITNET_1225
: PCI_DEVICE_ID_ZEITNET_1221
,
1835 dev
= atm_dev_register(DEV_LABEL
,&ops
,-1,0);
1837 zatm_dev
->pci_dev
= pci_dev
;
1838 ZATM_DEV(dev
) = zatm_dev
;
1839 zatm_dev
->copper
= type
;
1840 if (zatm_init(dev
) || zatm_start(dev
)) {
1841 atm_dev_deregister(dev
);
1844 zatm_dev
->more
= zatm_boards
;
1847 zatm_dev
= (struct zatm_dev
*) kmalloc(sizeof(struct
1848 zatm_dev
),GFP_KERNEL
);
1849 if (!zatm_dev
) break;
1858 int init_module(void)
1860 if (!zatm_detect()) {
1861 printk(KERN_ERR DEV_LABEL
": no adapter found\n");
1869 void cleanup_module(void)
1872 * Well, there's no way to get rid of the driver yet, so we don't
1873 * have to clean up, right ? :-)