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