?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.18pre1
[davej-history.git] / drivers / atm / zatm.c
blobbd1bd981f58387cac19a6bf1d98eea884d45d903
1 /* drivers/atm/zatm.c - ZeitNet ZN122x device driver */
2
3 /* Written 1995-1999 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 <asm/byteorder.h>
25 #include <asm/system.h>
26 #include <asm/string.h>
27 #include <asm/io.h>
28 #include <asm/uaccess.h>
29
30 #include "uPD98401.h"
31 #include "uPD98402.h"
32 #include "zeprom.h"
33 #include "zatm.h"
34
35
36 /*
37 * TODO:
38 *
39 * Minor features
40 * - support 64 kB SDUs (will have to use multibuffer batches then :-( )
41 * - proper use of CDV, credit = max(1,CDVT*PCR)
42 * - AAL0
43 * - better receive timestamps
44 * - OAM
45 */
46
47 #if 0
48 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
49 #else
50 #define DPRINTK(format,args...)
51 #endif
52
53
54 #ifndef CONFIG_ATM_ZATM_DEBUG
55
56
57 #define NULLCHECK(x)
58
59 #define EVENT(s,a,b)
60
61
62 static void event_dump(void)
63 {
64 }
65
66
67 #else
68
69
70 /*
71 * NULL pointer checking
72 */
73
74 #define NULLCHECK(x) \
75 if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x))
76
77 /*
78 * Very extensive activity logging. Greatly improves bug detection speed but
79 * costs a few Mbps if enabled.
80 */
81
82 #define EV 64
83
84 static const char *ev[EV];
85 static unsigned long ev_a[EV],ev_b[EV];
86 static int ec = 0;
87
88
89 static void EVENT(const char *s,unsigned long a,unsigned long b)
90 {
91 ev[ec] = s;
92 ev_a[ec] = a;
93 ev_b[ec] = b;
94 ec = (ec+1) % EV;
95 }
96
97
98 static void event_dump(void)
99 {
100 int n,i;
101
102 printk(KERN_NOTICE "----- event dump follows -----\n");
103 for (n = 0; n < EV; n++) {
104 i = (ec+n) % EV;
105 printk(KERN_NOTICE);
106 printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
107 }
108 printk(KERN_NOTICE "----- event dump ends here -----\n");
109 }
110
111
112 #endif /* CONFIG_ATM_ZATM_DEBUG */
113
114
115 #define RING_BUSY 1 /* indication from do_tx that PDU has to be
116 backlogged */
117
118 static struct atm_dev *zatm_boards = NULL;
119 static unsigned long dummy[2] = {0,0};
120
121
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)
126
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 */
130
131 #define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i])
132
133
134 /*-------------------------------- utilities --------------------------------*/
135
136
137 static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr)
138 {
139 zwait;
140 zout(value,CER);
141 zout(uPD98401_IND_ACC | uPD98401_IA_BALL |
142 (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
143 }
144
145
146 static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr)
147 {
148 zwait;
149 zout(uPD98401_IND_ACC | uPD98401_IA_BALL | uPD98401_IA_RW |
150 (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
151 zwait;
152 return zin(CER);
153 }
154
155
156 /*------------------------------- free lists --------------------------------*/
157
158
159 /*
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)
164 * [3] data
165 * ...
166 */
167
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) */
172 };
173
174
175 static void refill_pool(struct atm_dev *dev,int pool)
176 {
177 struct zatm_dev *zatm_dev;
178 struct sk_buff *skb;
179 struct rx_buffer_head *first;
180 unsigned long flags;
181 int align,offset,free,count,size;
182
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);
190 }
191 else {
192 align = 4096;
193 offset = zatm_dev->pool_info[pool].offset+
194 sizeof(struct rx_buffer_head);
195 }
196 size += align;
197 save_flags(flags);
198 cli();
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]);
207 count = 0;
208 first = NULL;
209 while (free < zatm_dev->pool_info[pool].high_water) {
210 struct rx_buffer_head *head;
211
212 skb = alloc_skb(size,GFP_ATOMIC);
213 if (!skb) {
214 printk(KERN_WARNING DEV_LABEL "(Itf %d): got no new "
215 "skb (%d) with %d free\n",dev->number,size,free);
216 break;
217 }
218 skb_reserve(skb,(unsigned char *) ((((unsigned long) skb->data+
219 align+offset-1) & ~(unsigned long) (align-1))-offset)-
220 skb->data);
221 head = (struct rx_buffer_head *) skb->data;
222 skb_reserve(skb,sizeof(struct rx_buffer_head));
223 if (!first) first = head;
224 count++;
225 head->buffer = virt_to_bus(skb->data);
226 head->link = 0;
227 head->skb = skb;
228 EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb,
229 (unsigned long) head);
230 cli();
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);
237 free++;
238 }
239 if (first) {
240 cli();
241 zwait;
242 zout(virt_to_bus(first),CER);
243 zout(uPD98401_ADD_BAT | (pool << uPD98401_POOL_SHIFT) | count,
244 CMR);
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]);
250 }
251 }
252
253
254 static void drain_free(struct atm_dev *dev,int pool)
255 {
256 struct sk_buff *skb;
257
258 while ((skb = skb_dequeue(&ZATM_DEV(dev)->pool[pool]))) kfree_skb(skb);
259 }
260
261
262 static int pool_index(int max_pdu)
263 {
264 int i;
265
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;
272 }
273
274
275 /* use_pool isn't reentrant */
276
277
278 static void use_pool(struct atm_dev *dev,int pool)
279 {
280 struct zatm_dev *zatm_dev;
281 unsigned long flags;
282 int size;
283
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 */
290 save_flags(flags);
291 cli();
292 zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) <<
293 uPD98401_RXFP_ALERT_SHIFT) |
294 (1 << uPD98401_RXFP_BTSZ_SHIFT) |
295 (size << uPD98401_RXFP_BFSZ_SHIFT),
296 zatm_dev->pool_base+pool*2);
297 zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+
298 pool*2+1);
299 restore_flags(flags);
300 zatm_dev->last_free[pool] = NULL;
301 refill_pool(dev,pool);
302 }
303 DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count);
304 }
305
306
307 static void unuse_pool(struct atm_dev *dev,int pool)
308 {
309 if (!(--ZATM_DEV(dev)->pool_info[pool].ref_count))
310 drain_free(dev,pool);
311 }
312
313
314 static void zatm_feedback(struct atm_vcc *vcc,struct sk_buff *skb,
315 unsigned long start,unsigned long dest,int len)
316 {
317 struct zatm_pool_info *pool;
318 unsigned long offset,flags;
319
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);
324 save_flags(flags);
325 cli();
326 if (!offset || pool->offset == offset) {
327 pool->next_cnt = 0;
328 restore_flags(flags);
329 return;
330 }
331 if (offset != pool->next_off) {
332 pool->next_off = offset;
333 pool->next_cnt = 0;
334 restore_flags(flags);
335 return;
336 }
337 if (++pool->next_cnt >= pool->next_thres) {
338 pool->offset = pool->next_off;
339 pool->next_cnt = 0;
340 }
341 restore_flags(flags);
342 }
343
344
345 /*----------------------- high-precision timestamps -------------------------*/
346
347
348 #ifdef CONFIG_ATM_ZATM_EXACT_TS
349
350 static struct timer_list sync_timer;
351
352
353 /*
354 * Note: the exact time is not normalized, i.e. tv_usec can be > 1000000.
355 * This must be handled by higher layers.
356 */
357
358 static inline struct timeval exact_time(struct zatm_dev *zatm_dev,u32 ticks)
359 {
360 struct timeval tmp;
361
362 tmp = zatm_dev->last_time;
363 tmp.tv_usec += ((s64) (ticks-zatm_dev->last_clk)*
364 (s64) zatm_dev->factor) >> TIMER_SHIFT;
365 return tmp;
366 }
367
368
369 static void zatm_clock_sync(unsigned long dummy)
370 {
371 struct atm_dev *atm_dev;
372 struct zatm_dev *zatm_dev;
373
374 for (atm_dev = zatm_boards; atm_dev; atm_dev = zatm_dev->more) {
375 unsigned long flags,interval;
376 int diff;
377 struct timeval now,expected;
378 u32 ticks;
379
380 zatm_dev = ZATM_DEV(atm_dev);
381 save_flags(flags);
382 cli();
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;
397 else
398 #ifndef AGGRESSIVE_DEBUGGING
399 if (++zatm_dev->timer_diffs >= ADJ_MSG_THRES)
400 #endif
401 {
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);
413 #endif
414 }
415 if (diff < -ADJ_IGN_THRES || diff > ADJ_IGN_THRES) {
416 /* filter out any major changes (e.g. time zone setup and
417 such) */
418 zatm_dev->last_time = now;
419 zatm_dev->factor =
420 (1000 << TIMER_SHIFT)/(zatm_dev->khz+1);
421 }
422 else {
423 zatm_dev->last_time = expected;
424 /*
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 ...
428 *
429 * What it does is simply:
430 *
431 * zatm_dev->factor = (interval << TIMER_SHIFT)/
432 * (ticks-zatm_dev->last_clk);
433 */
434 #define S(x) #x /* "stringification" ... */
435 #define SX(x) S(x)
436 asm("movl %2,%%ebx\n\t"
437 "subl %3,%%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"
441 "divl %%ebx\n\t"
442 : "=eax" (zatm_dev->factor)
443 : "eax" (interval-diff),"g" (ticks),
444 "g" (zatm_dev->last_clk)
445 : "ebx","edx","cc");
446 #undef S
447 #undef SX
448 #ifdef AGGRESSIVE_DEBUGGING
449 printk(KERN_DEBUG " (%ld << %d)/(%u-%u) = %u\n",
450 interval,TIMER_SHIFT,ticks,zatm_dev->last_clk,
451 zatm_dev->factor);
452 #endif
453 }
454 zatm_dev->last_real_time = now;
455 zatm_dev->last_clk = ticks;
456 }
457 mod_timer(&sync_timer,sync_timer.expires+POLL_INTERVAL*HZ);
458 }
459
460
461 static void __init zatm_clock_init(struct zatm_dev *zatm_dev)
462 {
463 static int start_timer = 1;
464 unsigned long flags;
465
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;
470 save_flags(flags);
471 cli();
472 do_gettimeofday(&zatm_dev->last_time);
473 zatm_dev->last_clk = zpeekl(zatm_dev,uPD98401_TSR);
474 if (start_timer) {
475 start_timer = 0;
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);
480 }
481 restore_flags(flags);
482 }
483
484
485 #endif
486
487
488 /*----------------------------------- RX ------------------------------------*/
489
490
491 #if 0
492 static void exception(struct atm_vcc *vcc)
493 {
494 static int count = 0;
495 struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev);
496 struct zatm_vcc *zatm_vcc = ZATM_VCC(vcc);
497 unsigned long *qrp;
498 int i;
499
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+
508 uPD98401_TXVC_QRP);
509 printk("qrp=0x%08lx\n",(unsigned long) qrp);
510 for (i = 0; i < 4; i++) printk("QRP[%d]: 0x%08lx",i,qrp[i]);
511 }
512 #endif
513
514
515 static const char *err_txt[] = {
516 "No error",
517 "RX buf underflow",
518 "RX FIFO overrun",
519 "Maximum len violation",
520 "CRC error",
521 "User abort",
522 "Length violation",
523 "T1 error",
524 "Deactivated",
525 "???",
526 "???",
527 "???",
528 "???",
529 "???",
530 "???",
531 "???"
532 };
533
534
535 static void poll_rx(struct atm_dev *dev,int mbx)
536 {
537 struct zatm_dev *zatm_dev;
538 unsigned long pos;
539 u32 x;
540 int error;
541
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) {
546 u32 *here;
547 struct sk_buff *skb;
548 struct atm_vcc *vcc;
549 int cells,size,chan;
550
551 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
552 here = (u32 *) pos;
553 if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
554 pos = zatm_dev->mbx_start[mbx];
555 cells = here[0] & uPD98401_AAL5_SIZE;
556 #if 0
557 printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]);
558 {
559 unsigned long *x;
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]);
566 }
567 #endif
568 error = 0;
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;
574 }
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]);
580 #else
581 skb->stamp = xtime;
582 #endif
583 #if 0
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]);
587 #endif
588 EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb,
589 (unsigned long) here);
590 #if 0
591 printk("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
592 #endif
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;
602 skb_unlink(skb);
603 }
604 else {
605 printk(KERN_ERR DEV_LABEL "(itf %d): RX indication "
606 "for non-existing channel\n",dev->number);
607 size = 0;
608 vcc = NULL;
609 event_dump();
610 }
611 if (error) {
612 static unsigned long silence = 0;
613 static int last_error = 0;
614
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,
619 err_txt[error]);
620 last_error = error;
621 silence = (jiffies+2*HZ)|1;
622 }
623 size = 0;
624 }
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);
629 size = 0;
630 event_dump();
631 }
632 if (size > ATM_MAX_AAL5_PDU) {
633 printk(KERN_ERR DEV_LABEL "(itf %d): size too big "
634 "(%d)\n",dev->number,size);
635 size = 0;
636 event_dump();
637 }
638 if (!size) {
639 kfree_skb(skb);
640 if (vcc) vcc->stats->rx_err++;
641 continue;
642 }
643 if (!atm_charge(vcc,skb->truesize)) {
644 kfree_skb(skb);
645 continue;
646 }
647 skb->len = size;
648 ATM_SKB(skb)->vcc = vcc;
649 vcc->push(vcc,skb);
650 vcc->stats->rx++;
651 }
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 */
656 #endif
657 }
658
659
660 static int open_rx_first(struct atm_vcc *vcc)
661 {
662 struct zatm_dev *zatm_dev;
663 struct zatm_vcc *zatm_vcc;
664 unsigned long flags;
665 unsigned short chan;
666 int cells;
667
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
677 later */
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);
681 }
682 else {
683 cells = 1;
684 zatm_vcc->pool = ZATM_AAL0_POOL;
685 }
686 if (zatm_vcc->pool < 0) return -EMSGSIZE;
687 save_flags(flags);
688 cli();
689 zwait;
690 zout(uPD98401_OPEN_CHAN,CMR);
691 zwait;
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 */
700 cli();
701 zpokel(zatm_dev,zatm_vcc->pool << uPD98401_RXVC_POOL_SHIFT,
702 chan*VC_SIZE/4);
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);
709 return 0;
710 }
711
712
713 static int open_rx_second(struct atm_vcc *vcc)
714 {
715 struct zatm_dev *zatm_dev;
716 struct zatm_vcc *zatm_vcc;
717 unsigned long flags;
718 int pos,shift;
719
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;
724 save_flags(flags);
725 cli();
726 /* should also handle VPI @@@ */
727 pos = vcc->vci >> 1;
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
733 scheme. @@@ */
734 if (vcc->rx_quota < 200000) vcc->rx_quota = 200000;
735 return 0;
736 }
737
738
739 static void close_rx(struct atm_vcc *vcc)
740 {
741 struct zatm_dev *zatm_dev;
742 struct zatm_vcc *zatm_vcc;
743 unsigned long flags;
744 int pos,shift;
745
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 */
751 save_flags(flags);
752 if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) {
753 cli();
754 pos = vcc->vci >> 1;
755 shift = (1-(vcc->vci & 1)) << 4;
756 zpokel(zatm_dev,zpeekl(zatm_dev,pos) & ~(0xffff << shift),pos);
757 zwait;
758 zout(uPD98401_NOP,CMR);
759 zwait;
760 zout(uPD98401_NOP,CMR);
761 restore_flags(flags);
762 }
763 cli();
764 zwait;
765 zout(uPD98401_DEACT_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
766 uPD98401_CHAN_ADDR_SHIFT),CMR);
767 zwait;
768 udelay(10); /* why oh why ... ? */
769 zout(uPD98401_CLOSE_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
770 uPD98401_CHAN_ADDR_SHIFT),CMR);
771 zwait;
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);
779 }
780
781
782 static int start_rx(struct atm_dev *dev)
783 {
784 struct zatm_dev *zatm_dev;
785 int size,i;
786
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;
806 }
807 return 0;
808 }
809
810
811 /*----------------------------------- TX ------------------------------------*/
812
813
814 static int do_tx(struct sk_buff *skb)
815 {
816 struct atm_vcc *vcc;
817 struct zatm_dev *zatm_dev;
818 struct zatm_vcc *zatm_vcc;
819 u32 *dsc;
820 unsigned long flags;
821
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);
828 save_flags(flags);
829 cli();
830 if (!ATM_SKB(skb)->iovcnt) {
831 if (zatm_vcc->txing == RING_ENTRIES-1) {
832 restore_flags(flags);
833 return RING_BUSY;
834 }
835 zatm_vcc->txing++;
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);
839 dsc[1] = 0;
840 dsc[2] = skb->len;
841 dsc[3] = virt_to_bus(skb->data);
842 mb();
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);
848 }
849 else {
850 printk("NONONONOO!!!!\n");
851 dsc = NULL;
852 #if 0
853 u32 *put;
854 int i;
855
856 dsc = (u32 *) kmalloc(uPD98401_TXPD_SIZE*2+
857 uPD98401_TXBD_SIZE*ATM_SKB(skb)->iovcnt,GFP_ATOMIC);
858 if (!dsc) {
859 if (vcc->pop) vcc->pop(vcc,skb);
860 else dev_kfree_skb(skb);
861 return -EAGAIN;
862 }
863 /* @@@ should check alignment */
864 put = dsc+8;
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));
869 dsc[1] = 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);
876 }
877 put[-2] |= uPD98401_TXBD_LAST;
878 #endif
879 }
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+
883 uPD98401_TXVC_QRP));
884 zwait;
885 zout(uPD98401_TX_READY | (zatm_vcc->tx_chan <<
886 uPD98401_CHAN_ADDR_SHIFT),CMR);
887 restore_flags(flags);
888 EVENT("done\n",0,0);
889 return 0;
890 }
891
892
893 static inline void dequeue_tx(struct atm_vcc *vcc)
894 {
895 struct zatm_vcc *zatm_vcc;
896 struct sk_buff *skb;
897
898 EVENT("dequeue_tx\n",0,0);
899 zatm_vcc = ZATM_VCC(vcc);
900 skb = skb_dequeue(&zatm_vcc->tx_queue);
901 if (!skb) {
902 printk(KERN_CRIT DEV_LABEL "(itf %d): dequeue_tx but not "
903 "txing\n",vcc->dev->number);
904 return;
905 }
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",
909 *ZATM_PRV_DSC(skb));
910 #endif
911 *ZATM_PRV_DSC(skb) = 0; /* mark as invalid */
912 zatm_vcc->txing--;
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);
918 break;
919 }
920 vcc->stats->tx++;
921 wake_up(&zatm_vcc->tx_wait);
922 }
923
924
925 static void poll_tx(struct atm_dev *dev,int mbx)
926 {
927 struct zatm_dev *zatm_dev;
928 unsigned long pos;
929 u32 x;
930
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) {
935 int chan;
936
937 #if 1
938 u32 data,*addr;
939
940 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
941 addr = (u32 *) pos;
942 data = *addr;
943 chan = (data & uPD98401_TXI_CONN) >> uPD98401_TXI_CONN_SHIFT;
944 EVENT("addr = 0x%lx, data = 0x%08x,",(unsigned long) addr,
945 data);
946 EVENT("chan = %d\n",chan,0);
947 #else
948 NO !
949 chan = (zatm_dev->mbx_start[mbx][pos >> 2] & uPD98401_TXI_CONN)
950 >> uPD98401_TXI_CONN_SHIFT;
951 #endif
952 if (chan < zatm_dev->chans && zatm_dev->tx_map[chan])
953 dequeue_tx(zatm_dev->tx_map[chan]);
954 else {
955 printk(KERN_CRIT DEV_LABEL "(itf %d): TX indication "
956 "for non-existing channel %d\n",dev->number,chan);
957 event_dump();
958 }
959 if (((pos += 4) & 0xffff) == zatm_dev->mbx_end[mbx])
960 pos = zatm_dev->mbx_start[mbx];
961 }
962 zout(pos & 0xffff,MTA(mbx));
963 }
964
965
966 /*
967 * BUG BUG BUG: Doesn't handle "new-style" rate specification yet.
968 */
969
970 static int alloc_shaper(struct atm_dev *dev,int *pcr,int min,int max,int ubr)
971 {
972 struct zatm_dev *zatm_dev;
973 unsigned long flags;
974 unsigned long i,m,c;
975 int shaper;
976
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;
982 if (ubr) {
983 c = 5;
984 i = m = 1;
985 zatm_dev->ubr_ref_cnt++;
986 zatm_dev->ubr = shaper;
987 }
988 else {
989 if (min) {
990 if (min <= 255) {
991 i = min;
992 m = ATM_OC3_PCR;
993 }
994 else {
995 i = 255;
996 m = ATM_OC3_PCR*255/min;
997 }
998 }
999 else {
1000 if (max > zatm_dev->tx_bw) max = zatm_dev->tx_bw;
1001 if (max <= 255) {
1002 i = max;
1003 m = ATM_OC3_PCR;
1004 }
1005 else {
1006 i = 255;
1007 m = (ATM_OC3_PCR*255+max-1)/max;
1008 }
1009 }
1010 if (i > m) {
1011 printk(KERN_CRIT DEV_LABEL "shaper algorithm botched "
1012 "[%d,%d] -> i=%ld,m=%ld\n",min,max,i,m);
1013 m = i;
1014 }
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;
1020 }
1021 save_flags(flags);
1022 cli();
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);
1030 return shaper;
1031 }
1032
1033
1034 static void dealloc_shaper(struct atm_dev *dev,int shaper)
1035 {
1036 struct zatm_dev *zatm_dev;
1037 unsigned long flags;
1038
1039 zatm_dev = ZATM_DEV(dev);
1040 if (shaper == zatm_dev->ubr) {
1041 if (--zatm_dev->ubr_ref_cnt) return;
1042 zatm_dev->ubr = -1;
1043 }
1044 save_flags(flags);
1045 cli();
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;
1050 }
1051
1052
1053 static void close_tx(struct atm_vcc *vcc)
1054 {
1055 struct zatm_dev *zatm_dev;
1056 struct zatm_vcc *zatm_vcc;
1057 unsigned long flags;
1058 int chan;
1059 struct sk_buff *skb;
1060 int once = 1;
1061
1062 zatm_vcc = ZATM_VCC(vcc);
1063 zatm_dev = ZATM_DEV(vcc->dev);
1064 chan = zatm_vcc->tx_chan;
1065 if (!chan) return;
1066 DPRINTK("close_tx\n");
1067 save_flags(flags);
1068 cli();
1069 while (skb_peek(&zatm_vcc->backlog)) {
1070 if (once) {
1071 printk("waiting for backlog to drain ...\n");
1072 event_dump();
1073 once = 0;
1074 }
1075 sleep_on(&zatm_vcc->tx_wait);
1076 }
1077 once = 1;
1078 while ((skb = skb_peek(&zatm_vcc->tx_queue))) {
1079 if (once) {
1080 printk("waiting for TX queue to drain ... %p\n",skb);
1081 event_dump();
1082 once = 0;
1083 }
1084 DPRINTK("waiting for TX queue to drain ... %p\n",skb);
1085 sleep_on(&zatm_vcc->tx_wait);
1086 }
1087 #if 0
1088 zwait;
1089 zout(uPD98401_DEACT_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
1090 #endif
1091 zwait;
1092 zout(uPD98401_CLOSE_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
1093 zwait;
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);
1103 }
1104 if (zatm_vcc->ring) kfree(zatm_vcc->ring);
1105 }
1106
1107
1108 static int open_tx_first(struct atm_vcc *vcc)
1109 {
1110 struct zatm_dev *zatm_dev;
1111 struct zatm_vcc *zatm_vcc;
1112 unsigned long flags;
1113 u32 *loop;
1114 unsigned short chan;
1115 int pcr,unlimited;
1116
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;
1122 save_flags(flags);
1123 cli();
1124 zwait;
1125 zout(uPD98401_OPEN_CHAN,CMR);
1126 zwait;
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;
1136 else {
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))
1140 < 0) {
1141 close_tx(vcc);
1142 return zatm_vcc->shaper;
1143 }
1144 if (pcr > ATM_OC3_PCR) pcr = ATM_OC3_PCR;
1145 vcc->qos.txtp.min_pcr = vcc->qos.txtp.max_pcr = pcr;
1146 }
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);
1163 return 0;
1164 }
1165
1166
1167 static int open_tx_second(struct atm_vcc *vcc)
1168 {
1169 struct zatm_dev *zatm_dev;
1170 struct zatm_vcc *zatm_vcc;
1171 unsigned long flags;
1172
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;
1177 save_flags(flags);
1178 /* set up VC descriptor */
1179 cli();
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;
1187 return 0;
1188 }
1189
1190
1191 static int start_tx(struct atm_dev *dev)
1192 {
1193 struct zatm_dev *zatm_dev;
1194 int i;
1195
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;
1203 zatm_dev->ubr = -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));
1207 return 0;
1208 }
1209
1210
1211 /*------------------------------- interrupts --------------------------------*/
1212
1213
1214 static void zatm_int(int irq,void *dev_id,struct pt_regs *regs)
1215 {
1216 struct atm_dev *dev;
1217 struct zatm_dev *zatm_dev;
1218 u32 reason;
1219
1220 dev = dev_id;
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);
1227 }
1228 if (reason & uPD98401_INT_RQA) {
1229 unsigned long pools;
1230 int i;
1231
1232 pools = zin(RQA);
1233 EVENT("RQA (0x%08x)\n",pools,0);
1234 for (i = 0; pools; i++) {
1235 if (pools & 1) {
1236 refill_pool(dev,i);
1237 zatm_dev->pool_info[i].rqa_count++;
1238 }
1239 pools >>= 1;
1240 }
1241 }
1242 if (reason & uPD98401_INT_RQU) {
1243 unsigned long pools;
1244 int i;
1245 pools = zin(RQU);
1246 printk(KERN_WARNING DEV_LABEL "(itf %d): RQU 0x%08lx\n",
1247 dev->number,pools);
1248 event_dump();
1249 for (i = 0; pools; i++) {
1250 if (pools & 1) {
1251 refill_pool(dev,i);
1252 zatm_dev->pool_info[i].rqu_count++;
1253 }
1254 pools >>= 1;
1255 }
1256 }
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));
1267 event_dump();
1268 }
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);
1274 event_dump();
1275 /* @@@ should try to recover */
1276 }
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);
1282 }
1283 /* @@@ handle RCRn */
1284 }
1285 }
1286
1287
1288 /*----------------------------- (E)EPROM access -----------------------------*/
1289
1290
1291 static void __init eprom_set(struct zatm_dev *zatm_dev,unsigned long value,
1292 unsigned short cmd)
1293 {
1294 int error;
1295
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",
1298 error);
1299 }
1300
1301
1302 static unsigned long __init eprom_get(struct zatm_dev *zatm_dev,
1303 unsigned short cmd)
1304 {
1305 unsigned int value;
1306 int error;
1307
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",
1310 error);
1311 return value;
1312 }
1313
1314
1315 static void __init eprom_put_bits(struct zatm_dev *zatm_dev,
1316 unsigned long data,int bits,unsigned short cmd)
1317 {
1318 unsigned long value;
1319 int i;
1320
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);
1326 }
1327 }
1328
1329
1330 static void __init eprom_get_byte(struct zatm_dev *zatm_dev,
1331 unsigned char *byte,unsigned short cmd)
1332 {
1333 int i;
1334
1335 *byte = 0;
1336 for (i = 8; i; i--) {
1337 eprom_set(zatm_dev,ZEPROM_CS,cmd);
1338 eprom_set(zatm_dev,ZEPROM_CS | ZEPROM_SK,cmd);
1339 *byte <<= 1;
1340 if (eprom_get(zatm_dev,cmd) & ZEPROM_DO) *byte |= 1;
1341 eprom_set(zatm_dev,ZEPROM_CS,cmd);
1342 }
1343 }
1344
1345
1346 static unsigned char __init eprom_try_esi(struct atm_dev *dev,
1347 unsigned short cmd,int offset,int swap)
1348 {
1349 unsigned char buf[ZEPROM_SIZE];
1350 struct zatm_dev *zatm_dev;
1351 int i;
1352
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 */
1361 }
1362 memcpy(dev->esi,buf+offset,ESI_LEN);
1363 return memcmp(dev->esi,"\0\0\0\0\0",ESI_LEN); /* assumes ESI_LEN == 6 */
1364 }
1365
1366
1367 static void __init eprom_get_esi(struct atm_dev *dev)
1368 {
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);
1371 }
1372
1373
1374 /*--------------------------------- entries ---------------------------------*/
1375
1376
1377 static int __init zatm_init(struct atm_dev *dev)
1378 {
1379 struct zatm_dev *zatm_dev;
1380 struct pci_dev *pci_dev;
1381 unsigned short command;
1382 unsigned char revision;
1383 int error,i,last;
1384 unsigned long t0,t1,t2;
1385
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",
1394 dev->number,error);
1395 return -EINVAL;
1396 }
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);
1401 return error;
1402 }
1403 eprom_get_esi(dev);
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 */
1407 zout(0,SWR);
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;
1414 else {
1415 zpokel(zatm_dev,0xAAAAAAAA,i);
1416 if (zpeekl(zatm_dev,i) != 0xAAAAAAAA) last = i;
1417 else zpokel(zatm_dev,i,i);
1418 }
1419 }
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 */
1425 zout(0,SWR);
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" :
1431 "MMF");
1432 for (i = 0; i < ESI_LEN; i++)
1433 printk("%02X%s",dev->esi[i],i == ESI_LEN-1 ? ")\n" : "-");
1434 do {
1435 unsigned long flags;
1436
1437 save_flags(flags);
1438 cli();
1439 t0 = zpeekl(zatm_dev,uPD98401_TSR);
1440 udelay(10);
1441 t1 = zpeekl(zatm_dev,uPD98401_TSR);
1442 udelay(1010);
1443 t2 = zpeekl(zatm_dev,uPD98401_TSR);
1444 restore_flags(flags);
1445 }
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);
1454 #endif
1455 return uPD98402_init(dev);
1456 }
1457
1458
1459 static int __init zatm_start(struct atm_dev *dev)
1460 {
1461 struct zatm_dev *zatm_dev;
1462 unsigned long curr;
1463 int pools,vccs,rx;
1464 int error,i,ld;
1465
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);
1471 return -EAGAIN;
1472 }
1473 request_region(zatm_dev->base,uPD98401_PORTS,DEV_LABEL);
1474 /* define memory regions */
1475 pools = NR_POOLS;
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);
1480 ld = -1;
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]) {
1503 unsigned long here;
1504
1505 here = (unsigned long) kmalloc(2*MBX_SIZE(i),
1506 GFP_KERNEL);
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",
1513 dev->number);
1514 kfree((void *) here);
1515 return -ENODEV;
1516 }
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));
1525 }
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);
1535 return 0;
1536 }
1537
1538
1539 static void zatm_close(struct atm_vcc *vcc)
1540 {
1541 DPRINTK(">zatm_close\n");
1542 if (!ZATM_VCC(vcc)) return;
1543 vcc->flags &= ~ATM_VF_READY;
1544 close_rx(vcc);
1545 EVENT("close_tx\n",0,0);
1546 close_tx(vcc);
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;
1552 }
1553
1554
1555 static int zatm_open(struct atm_vcc *vcc,short vpi,int vci)
1556 {
1557 struct zatm_dev *zatm_dev;
1558 struct zatm_vcc *zatm_vcc;
1559 int error;
1560
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;
1566 vcc->vpi = vpi;
1567 vcc->vci = vci;
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,
1572 vcc->vci);
1573 if (!(vcc->flags & ATM_VF_PARTIAL)) {
1574 zatm_vcc = kmalloc(sizeof(struct zatm_vcc),GFP_KERNEL);
1575 if (!zatm_vcc) {
1576 vcc->flags &= ~ATM_VF_ADDR;
1577 return -ENOMEM;
1578 }
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))) {
1582 zatm_close(vcc);
1583 return error;
1584 }
1585 if ((error = open_tx_first(vcc))) {
1586 zatm_close(vcc);
1587 return error;
1588 }
1589 }
1590 if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1591 if ((error = open_rx_second(vcc))) {
1592 zatm_close(vcc);
1593 return error;
1594 }
1595 if ((error = open_tx_second(vcc))) {
1596 zatm_close(vcc);
1597 return error;
1598 }
1599 vcc->flags |= ATM_VF_READY;
1600 return 0;
1601 }
1602
1603
1604 static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags)
1605 {
1606 printk("Not yet implemented\n");
1607 return -ENOSYS;
1608 /* @@@ */
1609 }
1610
1611
1612 static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void *arg)
1613 {
1614 struct zatm_dev *zatm_dev;
1615 unsigned long flags;
1616
1617 zatm_dev = ZATM_DEV(dev);
1618 switch (cmd) {
1619 case ZATM_GETPOOLZ:
1620 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1621 /* fall through */
1622 case ZATM_GETPOOL:
1623 {
1624 struct zatm_pool_info info;
1625 int pool;
1626
1627 if (get_user(pool,
1628 &((struct zatm_pool_req *) arg)->pool_num))
1629 return -EFAULT;
1630 if (pool < 0 || pool > ZATM_LAST_POOL)
1631 return -EINVAL;
1632 save_flags(flags);
1633 cli();
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;
1638 }
1639 restore_flags(flags);
1640 return copy_to_user(
1641 &((struct zatm_pool_req *) arg)->info,
1642 &info,sizeof(info)) ? -EFAULT : 0;
1643 }
1644 case ZATM_SETPOOL:
1645 {
1646 struct zatm_pool_info info;
1647 int pool;
1648
1649 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1650 if (get_user(pool,
1651 &((struct zatm_pool_req *) arg)->pool_num))
1652 return -EFAULT;
1653 if (pool < 0 || pool > ZATM_LAST_POOL)
1654 return -EINVAL;
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 ||
1668 info.low_water < 0)
1669 return -EINVAL;
1670 save_flags(flags);
1671 cli();
1672 zatm_dev->pool_info[pool].low_water =
1673 info.low_water;
1674 zatm_dev->pool_info[pool].high_water =
1675 info.high_water;
1676 zatm_dev->pool_info[pool].next_thres =
1677 info.next_thres;
1678 restore_flags(flags);
1679 return 0;
1680 }
1681 #ifdef CONFIG_ATM_ZATM_EXACT_TS
1682 case ZATM_GETTHIST:
1683 {
1684 int i;
1685
1686 save_flags(flags);
1687 cli();
1688 for (i = 0; i < ZATM_TIMER_HISTORY_SIZE; i++) {
1689 if (!copy_to_user(
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)))
1695 continue;
1696 restore_flags(flags);
1697 return -EFAULT;
1698 }
1699 restore_flags(flags);
1700 return 0;
1701 }
1702 #endif
1703 default:
1704 if (!dev->phy->ioctl) return -EINVAL;
1705 return dev->phy->ioctl(dev,cmd,arg);
1706 }
1707 }
1708
1709
1710 static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname,
1711 void *optval,int optlen)
1712 {
1713 #ifdef CONFIG_MMU_HACKS
1714
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 };
1717
1718 #else
1719
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 };
1722
1723 #endif
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;
1728 return -EINVAL;
1729 }
1730
1731
1732 static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname,
1733 void *optval,int optlen)
1734 {
1735 return -EINVAL;
1736 }
1737
1738
1739 #if 0
1740 static int zatm_sg_send(struct atm_vcc *vcc,unsigned long start,
1741 unsigned long size)
1742 {
1743 return vcc->aal == ATM_AAL5;
1744 /* @@@ should check size and maybe alignment*/
1745 }
1746 #endif
1747
1748
1749 static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb)
1750 {
1751 int error;
1752
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);
1757 return -EINVAL;
1758 }
1759 if (!skb) {
1760 printk(KERN_CRIT "!skb in zatm_send ?\n");
1761 if (vcc->pop) vcc->pop(vcc,skb);
1762 else dev_kfree_skb(skb);
1763 return -EINVAL;
1764 }
1765 ATM_SKB(skb)->vcc = vcc;
1766 error = do_tx(skb);
1767 if (error != RING_BUSY) return error;
1768 skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb);
1769 return 0;
1770 }
1771
1772
1773 static void zatm_phy_put(struct atm_dev *dev,unsigned char value,
1774 unsigned long addr)
1775 {
1776 struct zatm_dev *zatm_dev;
1777
1778 zatm_dev = ZATM_DEV(dev);
1779 zwait;
1780 zout(value,CER);
1781 zout(uPD98401_IND_ACC | uPD98401_IA_B0 |
1782 (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1783 }
1784
1785
1786 static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr)
1787 {
1788 struct zatm_dev *zatm_dev;
1789
1790 zatm_dev = ZATM_DEV(dev);
1791 zwait;
1792 zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW |
1793 (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1794 zwait;
1795 return zin(CER) & 0xff;
1796 }
1797
1798
1799 static const struct atmdev_ops ops = {
1800 NULL, /* no dev_close */
1801 zatm_open,
1802 zatm_close,
1803 zatm_ioctl,
1804 zatm_getsockopt,
1805 zatm_setsockopt,
1806 zatm_send,
1807 NULL /*zatm_sg_send*/,
1808 NULL, /* no send_oam */
1809 zatm_phy_put,
1810 zatm_phy_get,
1811 zatm_feedback,
1812 zatm_change_qos,
1813 NULL, /* no free_rx_skb */
1814 NULL /* no proc_read */
1815 };
1816
1817
1818 int __init zatm_detect(void)
1819 {
1820 struct atm_dev *dev;
1821 struct zatm_dev *zatm_dev;
1822 int devs,type;
1823
1824 zatm_dev = (struct zatm_dev *) kmalloc(sizeof(struct zatm_dev),
1825 GFP_KERNEL);
1826 if (!zatm_dev) return -ENOMEM;
1827 devs = 0;
1828 for (type = 0; type < 2; type++) {
1829 struct pci_dev *pci_dev;
1830
1831 pci_dev = NULL;
1832 while ((pci_dev = pci_find_device(PCI_VENDOR_ID_ZEITNET,type ?
1833 PCI_DEVICE_ID_ZEITNET_1225 : PCI_DEVICE_ID_ZEITNET_1221,
1834 pci_dev))) {
1835 dev = atm_dev_register(DEV_LABEL,&ops,-1,0);
1836 if (!dev) break;
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);
1842 break;
1843 }
1844 zatm_dev->more = zatm_boards;
1845 zatm_boards = dev;
1846 devs++;
1847 zatm_dev = (struct zatm_dev *) kmalloc(sizeof(struct
1848 zatm_dev),GFP_KERNEL);
1849 if (!zatm_dev) break;
1850 }
1851 }
1852 return devs;
1853 }
1854
1855
1856 #ifdef MODULE
1857
1858 int init_module(void)
1859 {
1860 if (!zatm_detect()) {
1861 printk(KERN_ERR DEV_LABEL ": no adapter found\n");
1862 return -ENXIO;
1863 }
1864 MOD_INC_USE_COUNT;
1865 return 0;
1866 }
1867
1868
1869 void cleanup_module(void)
1870 {
1871 /*
1872 * Well, there's no way to get rid of the driver yet, so we don't
1873 * have to clean up, right ? :-)
1874 */
1875 }
1876
1877 #endif
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux