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