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