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