projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
/spare/repo/libata-dev branch 'v2.6.13'
[deliverable/linux.git] / drivers / atm / zatm.c
1 /* drivers/atm/zatm.c - ZeitNet ZN122x device driver */
2
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
4
5
6 #include <linux/config.h>
7 #include <linux/module.h>
8 #include <linux/sched.h>
9 #include <linux/kernel.h>
10 #include <linux/mm.h>
11 #include <linux/pci.h>
12 #include <linux/errno.h>
13 #include <linux/atm.h>
14 #include <linux/atmdev.h>
15 #include <linux/sonet.h>
16 #include <linux/skbuff.h>
17 #include <linux/netdevice.h>
18 #include <linux/delay.h>
19 #include <linux/uio.h>
20 #include <linux/init.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/atm_zatm.h>
23 #include <linux/capability.h>
24 #include <linux/bitops.h>
25 #include <linux/wait.h>
26 #include <asm/byteorder.h>
27 #include <asm/system.h>
28 #include <asm/string.h>
29 #include <asm/io.h>
30 #include <asm/atomic.h>
31 #include <asm/uaccess.h>
32
33 #include "uPD98401.h"
34 #include "uPD98402.h"
35 #include "zeprom.h"
36 #include "zatm.h"
37
38
39 /*
40 * TODO:
41 *
42 * Minor features
43 * - support 64 kB SDUs (will have to use multibuffer batches then :-( )
44 * - proper use of CDV, credit = max(1,CDVT*PCR)
45 * - AAL0
46 * - better receive timestamps
47 * - OAM
48 */
49
50 #define ZATM_COPPER 1
51
52 #if 0
53 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
54 #else
55 #define DPRINTK(format,args...)
56 #endif
57
58 #ifndef CONFIG_ATM_ZATM_DEBUG
59
60
61 #define NULLCHECK(x)
62
63 #define EVENT(s,a,b)
64
65
66 static void event_dump(void)
67 {
68 }
69
70
71 #else
72
73
74 /*
75 * NULL pointer checking
76 */
77
78 #define NULLCHECK(x) \
79 if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x))
80
81 /*
82 * Very extensive activity logging. Greatly improves bug detection speed but
83 * costs a few Mbps if enabled.
84 */
85
86 #define EV 64
87
88 static const char *ev[EV];
89 static unsigned long ev_a[EV],ev_b[EV];
90 static int ec = 0;
91
92
93 static void EVENT(const char *s,unsigned long a,unsigned long b)
94 {
95 ev[ec] = s;
96 ev_a[ec] = a;
97 ev_b[ec] = b;
98 ec = (ec+1) % EV;
99 }
100
101
102 static void event_dump(void)
103 {
104 int n,i;
105
106 printk(KERN_NOTICE "----- event dump follows -----\n");
107 for (n = 0; n < EV; n++) {
108 i = (ec+n) % EV;
109 printk(KERN_NOTICE);
110 printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
111 }
112 printk(KERN_NOTICE "----- event dump ends here -----\n");
113 }
114
115
116 #endif /* CONFIG_ATM_ZATM_DEBUG */
117
118
119 #define RING_BUSY 1 /* indication from do_tx that PDU has to be
120 backlogged */
121
122 static struct atm_dev *zatm_boards = NULL;
123 static unsigned long dummy[2] = {0,0};
124
125
126 #define zin_n(r) inl(zatm_dev->base+r*4)
127 #define zin(r) inl(zatm_dev->base+uPD98401_##r*4)
128 #define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4)
129 #define zwait while (zin(CMR) & uPD98401_BUSY)
130
131 /* RX0, RX1, TX0, TX1 */
132 static const int mbx_entries[NR_MBX] = { 1024,1024,1024,1024 };
133 static const int mbx_esize[NR_MBX] = { 16,16,4,4 }; /* entry size in bytes */
134
135 #define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i])
136
137
138 /*-------------------------------- utilities --------------------------------*/
139
140
141 static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr)
142 {
143 zwait;
144 zout(value,CER);
145 zout(uPD98401_IND_ACC | uPD98401_IA_BALL |
146 (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
147 }
148
149
150 static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr)
151 {
152 zwait;
153 zout(uPD98401_IND_ACC | uPD98401_IA_BALL | uPD98401_IA_RW |
154 (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
155 zwait;
156 return zin(CER);
157 }
158
159
160 /*------------------------------- free lists --------------------------------*/
161
162
163 /*
164 * Free buffer head structure:
165 * [0] pointer to buffer (for SAR)
166 * [1] buffer descr link pointer (for SAR)
167 * [2] back pointer to skb (for poll_rx)
168 * [3] data
169 * ...
170 */
171
172 struct rx_buffer_head {
173 u32 buffer; /* pointer to buffer (for SAR) */
174 u32 link; /* buffer descriptor link pointer (for SAR) */
175 struct sk_buff *skb; /* back pointer to skb (for poll_rx) */
176 };
177
178
179 static void refill_pool(struct atm_dev *dev,int pool)
180 {
181 struct zatm_dev *zatm_dev;
182 struct sk_buff *skb;
183 struct rx_buffer_head *first;
184 unsigned long flags;
185 int align,offset,free,count,size;
186
187 EVENT("refill_pool\n",0,0);
188 zatm_dev = ZATM_DEV(dev);
189 size = (64 << (pool <= ZATM_AAL5_POOL_BASE ? 0 :
190 pool-ZATM_AAL5_POOL_BASE))+sizeof(struct rx_buffer_head);
191 if (size < PAGE_SIZE) {
192 align = 32; /* for 32 byte alignment */
193 offset = sizeof(struct rx_buffer_head);
194 }
195 else {
196 align = 4096;
197 offset = zatm_dev->pool_info[pool].offset+
198 sizeof(struct rx_buffer_head);
199 }
200 size += align;
201 spin_lock_irqsave(&zatm_dev->lock, flags);
202 free = zpeekl(zatm_dev,zatm_dev->pool_base+2*pool) &
203 uPD98401_RXFP_REMAIN;
204 spin_unlock_irqrestore(&zatm_dev->lock, flags);
205 if (free >= zatm_dev->pool_info[pool].low_water) return;
206 EVENT("starting ... POOL: 0x%x, 0x%x\n",
207 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
208 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
209 EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
210 count = 0;
211 first = NULL;
212 while (free < zatm_dev->pool_info[pool].high_water) {
213 struct rx_buffer_head *head;
214
215 skb = alloc_skb(size,GFP_ATOMIC);
216 if (!skb) {
217 printk(KERN_WARNING DEV_LABEL "(Itf %d): got no new "
218 "skb (%d) with %d free\n",dev->number,size,free);
219 break;
220 }
221 skb_reserve(skb,(unsigned char *) ((((unsigned long) skb->data+
222 align+offset-1) & ~(unsigned long) (align-1))-offset)-
223 skb->data);
224 head = (struct rx_buffer_head *) skb->data;
225 skb_reserve(skb,sizeof(struct rx_buffer_head));
226 if (!first) first = head;
227 count++;
228 head->buffer = virt_to_bus(skb->data);
229 head->link = 0;
230 head->skb = skb;
231 EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb,
232 (unsigned long) head);
233 spin_lock_irqsave(&zatm_dev->lock, flags);
234 if (zatm_dev->last_free[pool])
235 ((struct rx_buffer_head *) (zatm_dev->last_free[pool]->
236 data))[-1].link = virt_to_bus(head);
237 zatm_dev->last_free[pool] = skb;
238 skb_queue_tail(&zatm_dev->pool[pool],skb);
239 spin_unlock_irqrestore(&zatm_dev->lock, flags);
240 free++;
241 }
242 if (first) {
243 spin_lock_irqsave(&zatm_dev->lock, flags);
244 zwait;
245 zout(virt_to_bus(first),CER);
246 zout(uPD98401_ADD_BAT | (pool << uPD98401_POOL_SHIFT) | count,
247 CMR);
248 spin_unlock_irqrestore(&zatm_dev->lock, flags);
249 EVENT ("POOL: 0x%x, 0x%x\n",
250 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
251 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
252 EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
253 }
254 }
255
256
257 static void drain_free(struct atm_dev *dev,int pool)
258 {
259 skb_queue_purge(&ZATM_DEV(dev)->pool[pool]);
260 }
261
262
263 static int pool_index(int max_pdu)
264 {
265 int i;
266
267 if (max_pdu % ATM_CELL_PAYLOAD)
268 printk(KERN_ERR DEV_LABEL ": driver error in pool_index: "
269 "max_pdu is %d\n",max_pdu);
270 if (max_pdu > 65536) return -1;
271 for (i = 0; (64 << i) < max_pdu; i++);
272 return i+ZATM_AAL5_POOL_BASE;
273 }
274
275
276 /* use_pool isn't reentrant */
277
278
279 static void use_pool(struct atm_dev *dev,int pool)
280 {
281 struct zatm_dev *zatm_dev;
282 unsigned long flags;
283 int size;
284
285 zatm_dev = ZATM_DEV(dev);
286 if (!(zatm_dev->pool_info[pool].ref_count++)) {
287 skb_queue_head_init(&zatm_dev->pool[pool]);
288 size = pool-ZATM_AAL5_POOL_BASE;
289 if (size < 0) size = 0; /* 64B... */
290 else if (size > 10) size = 10; /* ... 64kB */
291 spin_lock_irqsave(&zatm_dev->lock, flags);
292 zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) <<
293 uPD98401_RXFP_ALERT_SHIFT) |
294 (1 << uPD98401_RXFP_BTSZ_SHIFT) |
295 (size << uPD98401_RXFP_BFSZ_SHIFT),
296 zatm_dev->pool_base+pool*2);
297 zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+
298 pool*2+1);
299 spin_unlock_irqrestore(&zatm_dev->lock, flags);
300 zatm_dev->last_free[pool] = NULL;
301 refill_pool(dev,pool);
302 }
303 DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count);
304 }
305
306
307 static void unuse_pool(struct atm_dev *dev,int pool)
308 {
309 if (!(--ZATM_DEV(dev)->pool_info[pool].ref_count))
310 drain_free(dev,pool);
311 }
312
313 /*----------------------------------- RX ------------------------------------*/
314
315
316 #if 0
317 static void exception(struct atm_vcc *vcc)
318 {
319 static int count = 0;
320 struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev);
321 struct zatm_vcc *zatm_vcc = ZATM_VCC(vcc);
322 unsigned long *qrp;
323 int i;
324
325 if (count++ > 2) return;
326 for (i = 0; i < 8; i++)
327 printk("TX%d: 0x%08lx\n",i,
328 zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+i));
329 for (i = 0; i < 5; i++)
330 printk("SH%d: 0x%08lx\n",i,
331 zpeekl(zatm_dev,uPD98401_IM(zatm_vcc->shaper)+16*i));
332 qrp = (unsigned long *) zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
333 uPD98401_TXVC_QRP);
334 printk("qrp=0x%08lx\n",(unsigned long) qrp);
335 for (i = 0; i < 4; i++) printk("QRP[%d]: 0x%08lx",i,qrp[i]);
336 }
337 #endif
338
339
340 static const char *err_txt[] = {
341 "No error",
342 "RX buf underflow",
343 "RX FIFO overrun",
344 "Maximum len violation",
345 "CRC error",
346 "User abort",
347 "Length violation",
348 "T1 error",
349 "Deactivated",
350 "???",
351 "???",
352 "???",
353 "???",
354 "???",
355 "???",
356 "???"
357 };
358
359
360 static void poll_rx(struct atm_dev *dev,int mbx)
361 {
362 struct zatm_dev *zatm_dev;
363 unsigned long pos;
364 u32 x;
365 int error;
366
367 EVENT("poll_rx\n",0,0);
368 zatm_dev = ZATM_DEV(dev);
369 pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
370 while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
371 u32 *here;
372 struct sk_buff *skb;
373 struct atm_vcc *vcc;
374 int cells,size,chan;
375
376 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
377 here = (u32 *) pos;
378 if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
379 pos = zatm_dev->mbx_start[mbx];
380 cells = here[0] & uPD98401_AAL5_SIZE;
381 #if 0
382 printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]);
383 {
384 unsigned long *x;
385 printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev,
386 zatm_dev->pool_base),
387 zpeekl(zatm_dev,zatm_dev->pool_base+1));
388 x = (unsigned long *) here[2];
389 printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
390 x[0],x[1],x[2],x[3]);
391 }
392 #endif
393 error = 0;
394 if (here[3] & uPD98401_AAL5_ERR) {
395 error = (here[3] & uPD98401_AAL5_ES) >>
396 uPD98401_AAL5_ES_SHIFT;
397 if (error == uPD98401_AAL5_ES_DEACT ||
398 error == uPD98401_AAL5_ES_FREE) continue;
399 }
400 EVENT("error code 0x%x/0x%x\n",(here[3] & uPD98401_AAL5_ES) >>
401 uPD98401_AAL5_ES_SHIFT,error);
402 skb = ((struct rx_buffer_head *) bus_to_virt(here[2]))->skb;
403 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 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 = ZATM_DEV(dev);
1261 struct pci_dev *pdev = zatm_dev->pci_dev;
1262 unsigned long curr;
1263 int pools,vccs,rx;
1264 int error, i, ld;
1265
1266 DPRINTK("zatm_start\n");
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 error = request_irq(zatm_dev->irq, zatm_int, SA_SHIRQ, DEV_LABEL, dev);
1271 if (error < 0) {
1272 printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1273 dev->number,zatm_dev->irq);
1274 goto done;
1275 }
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 void *mbx;
1304 dma_addr_t mbx_dma;
1305
1306 if (!mbx_entries[i])
1307 continue;
1308 mbx = pci_alloc_consistent(pdev, 2*MBX_SIZE(i), &mbx_dma);
1309 if (!mbx) {
1310 error = -ENOMEM;
1311 goto out;
1312 }
1313 /*
1314 * Alignment provided by pci_alloc_consistent() isn't enough
1315 * for this device.
1316 */
1317 if (((unsigned long)mbx ^ mbx_dma) & 0xffff) {
1318 printk(KERN_ERR DEV_LABEL "(itf %d): system "
1319 "bus incompatible with driver\n", dev->number);
1320 pci_free_consistent(pdev, 2*MBX_SIZE(i), mbx, mbx_dma);
1321 error = -ENODEV;
1322 goto out;
1323 }
1324 DPRINTK("mbx@0x%08lx-0x%08lx\n", mbx, mbx + MBX_SIZE(i));
1325 zatm_dev->mbx_start[i] = (unsigned long)mbx;
1326 zatm_dev->mbx_dma[i] = mbx_dma;
1327 zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) &
1328 0xffff;
1329 zout(mbx_dma >> 16, MSH(i));
1330 zout(mbx_dma, MSL(i));
1331 zout(zatm_dev->mbx_end[i], MBA(i));
1332 zout((unsigned long)mbx & 0xffff, MTA(i));
1333 zout((unsigned long)mbx & 0xffff, MWA(i));
1334 }
1335 error = start_tx(dev);
1336 if (error)
1337 goto out;
1338 error = start_rx(dev);
1339 if (error)
1340 goto out_tx;
1341 error = dev->phy->start(dev);
1342 if (error)
1343 goto out_rx;
1344 zout(0xffffffff,IMR); /* enable interrupts */
1345 /* enable TX & RX */
1346 zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR);
1347 done:
1348 return error;
1349
1350 out_rx:
1351 kfree(zatm_dev->rx_map);
1352 out_tx:
1353 kfree(zatm_dev->tx_map);
1354 out:
1355 while (i-- > 0) {
1356 pci_free_consistent(pdev, 2*MBX_SIZE(i),
1357 (void *)zatm_dev->mbx_start[i],
1358 zatm_dev->mbx_dma[i]);
1359 }
1360 free_irq(zatm_dev->irq, dev);
1361 goto done;
1362 }
1363
1364
1365 static void zatm_close(struct atm_vcc *vcc)
1366 {
1367 DPRINTK(">zatm_close\n");
1368 if (!ZATM_VCC(vcc)) return;
1369 clear_bit(ATM_VF_READY,&vcc->flags);
1370 close_rx(vcc);
1371 EVENT("close_tx\n",0,0);
1372 close_tx(vcc);
1373 DPRINTK("zatm_close: done waiting\n");
1374 /* deallocate memory */
1375 kfree(ZATM_VCC(vcc));
1376 vcc->dev_data = NULL;
1377 clear_bit(ATM_VF_ADDR,&vcc->flags);
1378 }
1379
1380
1381 static int zatm_open(struct atm_vcc *vcc)
1382 {
1383 struct zatm_dev *zatm_dev;
1384 struct zatm_vcc *zatm_vcc;
1385 short vpi = vcc->vpi;
1386 int vci = vcc->vci;
1387 int error;
1388
1389 DPRINTK(">zatm_open\n");
1390 zatm_dev = ZATM_DEV(vcc->dev);
1391 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1392 vcc->dev_data = NULL;
1393 if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1394 set_bit(ATM_VF_ADDR,&vcc->flags);
1395 if (vcc->qos.aal != ATM_AAL5) return -EINVAL; /* @@@ AAL0 */
1396 DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1397 vcc->vci);
1398 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1399 zatm_vcc = kmalloc(sizeof(struct zatm_vcc),GFP_KERNEL);
1400 if (!zatm_vcc) {
1401 clear_bit(ATM_VF_ADDR,&vcc->flags);
1402 return -ENOMEM;
1403 }
1404 vcc->dev_data = zatm_vcc;
1405 ZATM_VCC(vcc)->tx_chan = 0; /* for zatm_close after open_rx */
1406 if ((error = open_rx_first(vcc))) {
1407 zatm_close(vcc);
1408 return error;
1409 }
1410 if ((error = open_tx_first(vcc))) {
1411 zatm_close(vcc);
1412 return error;
1413 }
1414 }
1415 if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1416 if ((error = open_rx_second(vcc))) {
1417 zatm_close(vcc);
1418 return error;
1419 }
1420 if ((error = open_tx_second(vcc))) {
1421 zatm_close(vcc);
1422 return error;
1423 }
1424 set_bit(ATM_VF_READY,&vcc->flags);
1425 return 0;
1426 }
1427
1428
1429 static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags)
1430 {
1431 printk("Not yet implemented\n");
1432 return -ENOSYS;
1433 /* @@@ */
1434 }
1435
1436
1437 static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1438 {
1439 struct zatm_dev *zatm_dev;
1440 unsigned long flags;
1441
1442 zatm_dev = ZATM_DEV(dev);
1443 switch (cmd) {
1444 case ZATM_GETPOOLZ:
1445 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1446 /* fall through */
1447 case ZATM_GETPOOL:
1448 {
1449 struct zatm_pool_info info;
1450 int pool;
1451
1452 if (get_user(pool,
1453 &((struct zatm_pool_req __user *) arg)->pool_num))
1454 return -EFAULT;
1455 if (pool < 0 || pool > ZATM_LAST_POOL)
1456 return -EINVAL;
1457 spin_lock_irqsave(&zatm_dev->lock, flags);
1458 info = zatm_dev->pool_info[pool];
1459 if (cmd == ZATM_GETPOOLZ) {
1460 zatm_dev->pool_info[pool].rqa_count = 0;
1461 zatm_dev->pool_info[pool].rqu_count = 0;
1462 }
1463 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1464 return copy_to_user(
1465 &((struct zatm_pool_req __user *) arg)->info,
1466 &info,sizeof(info)) ? -EFAULT : 0;
1467 }
1468 case ZATM_SETPOOL:
1469 {
1470 struct zatm_pool_info info;
1471 int pool;
1472
1473 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1474 if (get_user(pool,
1475 &((struct zatm_pool_req __user *) arg)->pool_num))
1476 return -EFAULT;
1477 if (pool < 0 || pool > ZATM_LAST_POOL)
1478 return -EINVAL;
1479 if (copy_from_user(&info,
1480 &((struct zatm_pool_req __user *) arg)->info,
1481 sizeof(info))) return -EFAULT;
1482 if (!info.low_water)
1483 info.low_water = zatm_dev->
1484 pool_info[pool].low_water;
1485 if (!info.high_water)
1486 info.high_water = zatm_dev->
1487 pool_info[pool].high_water;
1488 if (!info.next_thres)
1489 info.next_thres = zatm_dev->
1490 pool_info[pool].next_thres;
1491 if (info.low_water >= info.high_water ||
1492 info.low_water < 0)
1493 return -EINVAL;
1494 spin_lock_irqsave(&zatm_dev->lock, flags);
1495 zatm_dev->pool_info[pool].low_water =
1496 info.low_water;
1497 zatm_dev->pool_info[pool].high_water =
1498 info.high_water;
1499 zatm_dev->pool_info[pool].next_thres =
1500 info.next_thres;
1501 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1502 return 0;
1503 }
1504 default:
1505 if (!dev->phy->ioctl) return -ENOIOCTLCMD;
1506 return dev->phy->ioctl(dev,cmd,arg);
1507 }
1508 }
1509
1510
1511 static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname,
1512 void __user *optval,int optlen)
1513 {
1514 return -EINVAL;
1515 }
1516
1517
1518 static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname,
1519 void __user *optval,int optlen)
1520 {
1521 return -EINVAL;
1522 }
1523
1524 static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb)
1525 {
1526 int error;
1527
1528 EVENT(">zatm_send 0x%lx\n",(unsigned long) skb,0);
1529 if (!ZATM_VCC(vcc)->tx_chan || !test_bit(ATM_VF_READY,&vcc->flags)) {
1530 if (vcc->pop) vcc->pop(vcc,skb);
1531 else dev_kfree_skb(skb);
1532 return -EINVAL;
1533 }
1534 if (!skb) {
1535 printk(KERN_CRIT "!skb in zatm_send ?\n");
1536 if (vcc->pop) vcc->pop(vcc,skb);
1537 return -EINVAL;
1538 }
1539 ATM_SKB(skb)->vcc = vcc;
1540 error = do_tx(skb);
1541 if (error != RING_BUSY) return error;
1542 skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb);
1543 return 0;
1544 }
1545
1546
1547 static void zatm_phy_put(struct atm_dev *dev,unsigned char value,
1548 unsigned long addr)
1549 {
1550 struct zatm_dev *zatm_dev;
1551
1552 zatm_dev = ZATM_DEV(dev);
1553 zwait;
1554 zout(value,CER);
1555 zout(uPD98401_IND_ACC | uPD98401_IA_B0 |
1556 (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1557 }
1558
1559
1560 static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr)
1561 {
1562 struct zatm_dev *zatm_dev;
1563
1564 zatm_dev = ZATM_DEV(dev);
1565 zwait;
1566 zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW |
1567 (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1568 zwait;
1569 return zin(CER) & 0xff;
1570 }
1571
1572
1573 static const struct atmdev_ops ops = {
1574 .open = zatm_open,
1575 .close = zatm_close,
1576 .ioctl = zatm_ioctl,
1577 .getsockopt = zatm_getsockopt,
1578 .setsockopt = zatm_setsockopt,
1579 .send = zatm_send,
1580 .phy_put = zatm_phy_put,
1581 .phy_get = zatm_phy_get,
1582 .change_qos = zatm_change_qos,
1583 };
1584
1585 static int __devinit zatm_init_one(struct pci_dev *pci_dev,
1586 const struct pci_device_id *ent)
1587 {
1588 struct atm_dev *dev;
1589 struct zatm_dev *zatm_dev;
1590 int ret = -ENOMEM;
1591
1592 zatm_dev = (struct zatm_dev *) kmalloc(sizeof(*zatm_dev), GFP_KERNEL);
1593 if (!zatm_dev) {
1594 printk(KERN_EMERG "%s: memory shortage\n", DEV_LABEL);
1595 goto out;
1596 }
1597
1598 dev = atm_dev_register(DEV_LABEL, &ops, -1, NULL);
1599 if (!dev)
1600 goto out_free;
1601
1602 ret = pci_enable_device(pci_dev);
1603 if (ret < 0)
1604 goto out_deregister;
1605
1606 ret = pci_request_regions(pci_dev, DEV_LABEL);
1607 if (ret < 0)
1608 goto out_disable;
1609
1610 zatm_dev->pci_dev = pci_dev;
1611 dev->dev_data = zatm_dev;
1612 zatm_dev->copper = (int)ent->driver_data;
1613 if ((ret = zatm_init(dev)) || (ret = zatm_start(dev)))
1614 goto out_release;
1615
1616 pci_set_drvdata(pci_dev, dev);
1617 zatm_dev->more = zatm_boards;
1618 zatm_boards = dev;
1619 ret = 0;
1620 out:
1621 return ret;
1622
1623 out_release:
1624 pci_release_regions(pci_dev);
1625 out_disable:
1626 pci_disable_device(pci_dev);
1627 out_deregister:
1628 atm_dev_deregister(dev);
1629 out_free:
1630 kfree(zatm_dev);
1631 goto out;
1632 }
1633
1634
1635 MODULE_LICENSE("GPL");
1636
1637 static struct pci_device_id zatm_pci_tbl[] __devinitdata = {
1638 { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1221,
1639 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ZATM_COPPER },
1640 { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1225,
1641 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1642 { 0, }
1643 };
1644 MODULE_DEVICE_TABLE(pci, zatm_pci_tbl);
1645
1646 static struct pci_driver zatm_driver = {
1647 .name = DEV_LABEL,
1648 .id_table = zatm_pci_tbl,
1649 .probe = zatm_init_one,
1650 };
1651
1652 static int __init zatm_init_module(void)
1653 {
1654 return pci_register_driver(&zatm_driver);
1655 }
1656
1657 module_init(zatm_init_module);
1658 /* module_exit not defined so not unloadable */
Linux kernel - Deliverables
This page took 0.067303 seconds and 6 git commands to generate.