]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* drivers/atm/zatm.c - ZeitNet ZN122x device driver */ |
2 | ||
3 | /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */ | |
4 | ||
5 | ||
1da177e4 | 6 | #include <linux/module.h> |
1da177e4 LT |
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> | |
1da177e4 LT |
17 | #include <linux/uio.h> |
18 | #include <linux/init.h> | |
4aa49d13 | 19 | #include <linux/dma-mapping.h> |
1da177e4 LT |
20 | #include <linux/atm_zatm.h> |
21 | #include <linux/capability.h> | |
22 | #include <linux/bitops.h> | |
23 | #include <linux/wait.h> | |
24 | #include <asm/byteorder.h> | |
25 | #include <asm/system.h> | |
26 | #include <asm/string.h> | |
27 | #include <asm/io.h> | |
28 | #include <asm/atomic.h> | |
29 | #include <asm/uaccess.h> | |
30 | ||
31 | #include "uPD98401.h" | |
32 | #include "uPD98402.h" | |
33 | #include "zeprom.h" | |
34 | #include "zatm.h" | |
35 | ||
36 | ||
37 | /* | |
38 | * TODO: | |
39 | * | |
40 | * Minor features | |
41 | * - support 64 kB SDUs (will have to use multibuffer batches then :-( ) | |
42 | * - proper use of CDV, credit = max(1,CDVT*PCR) | |
43 | * - AAL0 | |
44 | * - better receive timestamps | |
45 | * - OAM | |
46 | */ | |
47 | ||
48 | #define ZATM_COPPER 1 | |
49 | ||
50 | #if 0 | |
51 | #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args) | |
52 | #else | |
53 | #define DPRINTK(format,args...) | |
54 | #endif | |
55 | ||
56 | #ifndef CONFIG_ATM_ZATM_DEBUG | |
57 | ||
58 | ||
59 | #define NULLCHECK(x) | |
60 | ||
61 | #define EVENT(s,a,b) | |
62 | ||
63 | ||
64 | static void event_dump(void) | |
65 | { | |
66 | } | |
67 | ||
68 | ||
69 | #else | |
70 | ||
71 | ||
72 | /* | |
73 | * NULL pointer checking | |
74 | */ | |
75 | ||
76 | #define NULLCHECK(x) \ | |
77 | if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x)) | |
78 | ||
79 | /* | |
80 | * Very extensive activity logging. Greatly improves bug detection speed but | |
81 | * costs a few Mbps if enabled. | |
82 | */ | |
83 | ||
84 | #define EV 64 | |
85 | ||
86 | static const char *ev[EV]; | |
87 | static unsigned long ev_a[EV],ev_b[EV]; | |
88 | static int ec = 0; | |
89 | ||
90 | ||
91 | static void EVENT(const char *s,unsigned long a,unsigned long b) | |
92 | { | |
93 | ev[ec] = s; | |
94 | ev_a[ec] = a; | |
95 | ev_b[ec] = b; | |
96 | ec = (ec+1) % EV; | |
97 | } | |
98 | ||
99 | ||
100 | static void event_dump(void) | |
101 | { | |
102 | int n,i; | |
103 | ||
104 | printk(KERN_NOTICE "----- event dump follows -----\n"); | |
105 | for (n = 0; n < EV; n++) { | |
106 | i = (ec+n) % EV; | |
107 | printk(KERN_NOTICE); | |
108 | printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]); | |
109 | } | |
110 | printk(KERN_NOTICE "----- event dump ends here -----\n"); | |
111 | } | |
112 | ||
113 | ||
114 | #endif /* CONFIG_ATM_ZATM_DEBUG */ | |
115 | ||
116 | ||
117 | #define RING_BUSY 1 /* indication from do_tx that PDU has to be | |
118 | backlogged */ | |
119 | ||
120 | static struct atm_dev *zatm_boards = NULL; | |
121 | static unsigned long dummy[2] = {0,0}; | |
122 | ||
123 | ||
124 | #define zin_n(r) inl(zatm_dev->base+r*4) | |
125 | #define zin(r) inl(zatm_dev->base+uPD98401_##r*4) | |
126 | #define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4) | |
127 | #define zwait while (zin(CMR) & uPD98401_BUSY) | |
128 | ||
129 | /* RX0, RX1, TX0, TX1 */ | |
130 | static const int mbx_entries[NR_MBX] = { 1024,1024,1024,1024 }; | |
131 | static const int mbx_esize[NR_MBX] = { 16,16,4,4 }; /* entry size in bytes */ | |
132 | ||
133 | #define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i]) | |
134 | ||
135 | ||
136 | /*-------------------------------- utilities --------------------------------*/ | |
137 | ||
138 | ||
139 | static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr) | |
140 | { | |
141 | zwait; | |
142 | zout(value,CER); | |
143 | zout(uPD98401_IND_ACC | uPD98401_IA_BALL | | |
144 | (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR); | |
145 | } | |
146 | ||
147 | ||
148 | static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr) | |
149 | { | |
150 | zwait; | |
151 | zout(uPD98401_IND_ACC | uPD98401_IA_BALL | uPD98401_IA_RW | | |
152 | (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR); | |
153 | zwait; | |
154 | return zin(CER); | |
155 | } | |
156 | ||
157 | ||
158 | /*------------------------------- free lists --------------------------------*/ | |
159 | ||
160 | ||
161 | /* | |
162 | * Free buffer head structure: | |
163 | * [0] pointer to buffer (for SAR) | |
164 | * [1] buffer descr link pointer (for SAR) | |
165 | * [2] back pointer to skb (for poll_rx) | |
166 | * [3] data | |
167 | * ... | |
168 | */ | |
169 | ||
170 | struct rx_buffer_head { | |
171 | u32 buffer; /* pointer to buffer (for SAR) */ | |
172 | u32 link; /* buffer descriptor link pointer (for SAR) */ | |
173 | struct sk_buff *skb; /* back pointer to skb (for poll_rx) */ | |
174 | }; | |
175 | ||
176 | ||
177 | static void refill_pool(struct atm_dev *dev,int pool) | |
178 | { | |
179 | struct zatm_dev *zatm_dev; | |
180 | struct sk_buff *skb; | |
181 | struct rx_buffer_head *first; | |
182 | unsigned long flags; | |
183 | int align,offset,free,count,size; | |
184 | ||
185 | EVENT("refill_pool\n",0,0); | |
186 | zatm_dev = ZATM_DEV(dev); | |
187 | size = (64 << (pool <= ZATM_AAL5_POOL_BASE ? 0 : | |
188 | pool-ZATM_AAL5_POOL_BASE))+sizeof(struct rx_buffer_head); | |
189 | if (size < PAGE_SIZE) { | |
190 | align = 32; /* for 32 byte alignment */ | |
191 | offset = sizeof(struct rx_buffer_head); | |
192 | } | |
193 | else { | |
194 | align = 4096; | |
195 | offset = zatm_dev->pool_info[pool].offset+ | |
196 | sizeof(struct rx_buffer_head); | |
197 | } | |
198 | size += align; | |
199 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
200 | free = zpeekl(zatm_dev,zatm_dev->pool_base+2*pool) & | |
201 | uPD98401_RXFP_REMAIN; | |
202 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
203 | if (free >= zatm_dev->pool_info[pool].low_water) return; | |
204 | EVENT("starting ... POOL: 0x%x, 0x%x\n", | |
205 | zpeekl(zatm_dev,zatm_dev->pool_base+2*pool), | |
206 | zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1)); | |
207 | EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]); | |
208 | count = 0; | |
209 | first = NULL; | |
210 | while (free < zatm_dev->pool_info[pool].high_water) { | |
211 | struct rx_buffer_head *head; | |
212 | ||
213 | skb = alloc_skb(size,GFP_ATOMIC); | |
214 | if (!skb) { | |
215 | printk(KERN_WARNING DEV_LABEL "(Itf %d): got no new " | |
216 | "skb (%d) with %d free\n",dev->number,size,free); | |
217 | break; | |
218 | } | |
219 | skb_reserve(skb,(unsigned char *) ((((unsigned long) skb->data+ | |
220 | align+offset-1) & ~(unsigned long) (align-1))-offset)- | |
221 | skb->data); | |
222 | head = (struct rx_buffer_head *) skb->data; | |
223 | skb_reserve(skb,sizeof(struct rx_buffer_head)); | |
224 | if (!first) first = head; | |
225 | count++; | |
226 | head->buffer = virt_to_bus(skb->data); | |
227 | head->link = 0; | |
228 | head->skb = skb; | |
229 | EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb, | |
230 | (unsigned long) head); | |
231 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
232 | if (zatm_dev->last_free[pool]) | |
233 | ((struct rx_buffer_head *) (zatm_dev->last_free[pool]-> | |
234 | data))[-1].link = virt_to_bus(head); | |
235 | zatm_dev->last_free[pool] = skb; | |
236 | skb_queue_tail(&zatm_dev->pool[pool],skb); | |
237 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
238 | free++; | |
239 | } | |
240 | if (first) { | |
241 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
242 | zwait; | |
243 | zout(virt_to_bus(first),CER); | |
244 | zout(uPD98401_ADD_BAT | (pool << uPD98401_POOL_SHIFT) | count, | |
245 | CMR); | |
246 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
247 | EVENT ("POOL: 0x%x, 0x%x\n", | |
248 | zpeekl(zatm_dev,zatm_dev->pool_base+2*pool), | |
249 | zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1)); | |
250 | EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]); | |
251 | } | |
252 | } | |
253 | ||
254 | ||
255 | static void drain_free(struct atm_dev *dev,int pool) | |
256 | { | |
257 | skb_queue_purge(&ZATM_DEV(dev)->pool[pool]); | |
258 | } | |
259 | ||
260 | ||
261 | static int pool_index(int max_pdu) | |
262 | { | |
263 | int i; | |
264 | ||
265 | if (max_pdu % ATM_CELL_PAYLOAD) | |
266 | printk(KERN_ERR DEV_LABEL ": driver error in pool_index: " | |
267 | "max_pdu is %d\n",max_pdu); | |
268 | if (max_pdu > 65536) return -1; | |
269 | for (i = 0; (64 << i) < max_pdu; i++); | |
270 | return i+ZATM_AAL5_POOL_BASE; | |
271 | } | |
272 | ||
273 | ||
274 | /* use_pool isn't reentrant */ | |
275 | ||
276 | ||
277 | static void use_pool(struct atm_dev *dev,int pool) | |
278 | { | |
279 | struct zatm_dev *zatm_dev; | |
280 | unsigned long flags; | |
281 | int size; | |
282 | ||
283 | zatm_dev = ZATM_DEV(dev); | |
284 | if (!(zatm_dev->pool_info[pool].ref_count++)) { | |
285 | skb_queue_head_init(&zatm_dev->pool[pool]); | |
286 | size = pool-ZATM_AAL5_POOL_BASE; | |
287 | if (size < 0) size = 0; /* 64B... */ | |
288 | else if (size > 10) size = 10; /* ... 64kB */ | |
289 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
290 | zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) << | |
291 | uPD98401_RXFP_ALERT_SHIFT) | | |
292 | (1 << uPD98401_RXFP_BTSZ_SHIFT) | | |
293 | (size << uPD98401_RXFP_BFSZ_SHIFT), | |
294 | zatm_dev->pool_base+pool*2); | |
295 | zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+ | |
296 | pool*2+1); | |
297 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
298 | zatm_dev->last_free[pool] = NULL; | |
299 | refill_pool(dev,pool); | |
300 | } | |
301 | DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count); | |
302 | } | |
303 | ||
304 | ||
305 | static void unuse_pool(struct atm_dev *dev,int pool) | |
306 | { | |
307 | if (!(--ZATM_DEV(dev)->pool_info[pool].ref_count)) | |
308 | drain_free(dev,pool); | |
309 | } | |
310 | ||
311 | /*----------------------------------- RX ------------------------------------*/ | |
312 | ||
313 | ||
314 | #if 0 | |
315 | static void exception(struct atm_vcc *vcc) | |
316 | { | |
317 | static int count = 0; | |
318 | struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev); | |
319 | struct zatm_vcc *zatm_vcc = ZATM_VCC(vcc); | |
320 | unsigned long *qrp; | |
321 | int i; | |
322 | ||
323 | if (count++ > 2) return; | |
324 | for (i = 0; i < 8; i++) | |
325 | printk("TX%d: 0x%08lx\n",i, | |
326 | zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+i)); | |
327 | for (i = 0; i < 5; i++) | |
328 | printk("SH%d: 0x%08lx\n",i, | |
329 | zpeekl(zatm_dev,uPD98401_IM(zatm_vcc->shaper)+16*i)); | |
330 | qrp = (unsigned long *) zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+ | |
331 | uPD98401_TXVC_QRP); | |
332 | printk("qrp=0x%08lx\n",(unsigned long) qrp); | |
333 | for (i = 0; i < 4; i++) printk("QRP[%d]: 0x%08lx",i,qrp[i]); | |
334 | } | |
335 | #endif | |
336 | ||
337 | ||
338 | static const char *err_txt[] = { | |
339 | "No error", | |
340 | "RX buf underflow", | |
341 | "RX FIFO overrun", | |
342 | "Maximum len violation", | |
343 | "CRC error", | |
344 | "User abort", | |
345 | "Length violation", | |
346 | "T1 error", | |
347 | "Deactivated", | |
348 | "???", | |
349 | "???", | |
350 | "???", | |
351 | "???", | |
352 | "???", | |
353 | "???", | |
354 | "???" | |
355 | }; | |
356 | ||
357 | ||
358 | static void poll_rx(struct atm_dev *dev,int mbx) | |
359 | { | |
360 | struct zatm_dev *zatm_dev; | |
361 | unsigned long pos; | |
362 | u32 x; | |
363 | int error; | |
364 | ||
365 | EVENT("poll_rx\n",0,0); | |
366 | zatm_dev = ZATM_DEV(dev); | |
367 | pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx)); | |
368 | while (x = zin(MWA(mbx)), (pos & 0xffff) != x) { | |
369 | u32 *here; | |
370 | struct sk_buff *skb; | |
371 | struct atm_vcc *vcc; | |
372 | int cells,size,chan; | |
373 | ||
374 | EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x); | |
375 | here = (u32 *) pos; | |
376 | if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx]) | |
377 | pos = zatm_dev->mbx_start[mbx]; | |
378 | cells = here[0] & uPD98401_AAL5_SIZE; | |
379 | #if 0 | |
380 | printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]); | |
381 | { | |
382 | unsigned long *x; | |
383 | printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev, | |
384 | zatm_dev->pool_base), | |
385 | zpeekl(zatm_dev,zatm_dev->pool_base+1)); | |
386 | x = (unsigned long *) here[2]; | |
387 | printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n", | |
388 | x[0],x[1],x[2],x[3]); | |
389 | } | |
390 | #endif | |
391 | error = 0; | |
392 | if (here[3] & uPD98401_AAL5_ERR) { | |
393 | error = (here[3] & uPD98401_AAL5_ES) >> | |
394 | uPD98401_AAL5_ES_SHIFT; | |
395 | if (error == uPD98401_AAL5_ES_DEACT || | |
396 | error == uPD98401_AAL5_ES_FREE) continue; | |
397 | } | |
398 | EVENT("error code 0x%x/0x%x\n",(here[3] & uPD98401_AAL5_ES) >> | |
399 | uPD98401_AAL5_ES_SHIFT,error); | |
400 | skb = ((struct rx_buffer_head *) bus_to_virt(here[2]))->skb; | |
a61bbcf2 | 401 | __net_timestamp(skb); |
1da177e4 LT |
402 | #if 0 |
403 | printk("[-3..0] 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",((unsigned *) skb->data)[-3], | |
404 | ((unsigned *) skb->data)[-2],((unsigned *) skb->data)[-1], | |
405 | ((unsigned *) skb->data)[0]); | |
406 | #endif | |
407 | EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb, | |
408 | (unsigned long) here); | |
409 | #if 0 | |
410 | printk("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]); | |
411 | #endif | |
412 | size = error ? 0 : ntohs(((__be16 *) skb->data)[cells* | |
413 | ATM_CELL_PAYLOAD/sizeof(u16)-3]); | |
414 | EVENT("got skb 0x%lx, size %d\n",(unsigned long) skb,size); | |
415 | chan = (here[3] & uPD98401_AAL5_CHAN) >> | |
416 | uPD98401_AAL5_CHAN_SHIFT; | |
417 | if (chan < zatm_dev->chans && zatm_dev->rx_map[chan]) { | |
d70063c4 | 418 | int pos; |
1da177e4 | 419 | vcc = zatm_dev->rx_map[chan]; |
d70063c4 | 420 | pos = ZATM_VCC(vcc)->pool; |
8728b834 DM |
421 | if (skb == zatm_dev->last_free[pos]) |
422 | zatm_dev->last_free[pos] = NULL; | |
423 | skb_unlink(skb, zatm_dev->pool + pos); | |
1da177e4 LT |
424 | } |
425 | else { | |
426 | printk(KERN_ERR DEV_LABEL "(itf %d): RX indication " | |
427 | "for non-existing channel\n",dev->number); | |
428 | size = 0; | |
429 | vcc = NULL; | |
430 | event_dump(); | |
431 | } | |
432 | if (error) { | |
433 | static unsigned long silence = 0; | |
434 | static int last_error = 0; | |
435 | ||
436 | if (error != last_error || | |
437 | time_after(jiffies, silence) || silence == 0){ | |
438 | printk(KERN_WARNING DEV_LABEL "(itf %d): " | |
439 | "chan %d error %s\n",dev->number,chan, | |
440 | err_txt[error]); | |
441 | last_error = error; | |
442 | silence = (jiffies+2*HZ)|1; | |
443 | } | |
444 | size = 0; | |
445 | } | |
446 | if (size && (size > cells*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER || | |
447 | size <= (cells-1)*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER)) { | |
448 | printk(KERN_ERR DEV_LABEL "(itf %d): size %d with %d " | |
449 | "cells\n",dev->number,size,cells); | |
450 | size = 0; | |
451 | event_dump(); | |
452 | } | |
453 | if (size > ATM_MAX_AAL5_PDU) { | |
454 | printk(KERN_ERR DEV_LABEL "(itf %d): size too big " | |
455 | "(%d)\n",dev->number,size); | |
456 | size = 0; | |
457 | event_dump(); | |
458 | } | |
459 | if (!size) { | |
460 | dev_kfree_skb_irq(skb); | |
461 | if (vcc) atomic_inc(&vcc->stats->rx_err); | |
462 | continue; | |
463 | } | |
464 | if (!atm_charge(vcc,skb->truesize)) { | |
465 | dev_kfree_skb_irq(skb); | |
466 | continue; | |
467 | } | |
468 | skb->len = size; | |
469 | ATM_SKB(skb)->vcc = vcc; | |
470 | vcc->push(vcc,skb); | |
471 | atomic_inc(&vcc->stats->rx); | |
472 | } | |
473 | zout(pos & 0xffff,MTA(mbx)); | |
474 | #if 0 /* probably a stupid idea */ | |
475 | refill_pool(dev,zatm_vcc->pool); | |
476 | /* maybe this saves us a few interrupts */ | |
477 | #endif | |
478 | } | |
479 | ||
480 | ||
481 | static int open_rx_first(struct atm_vcc *vcc) | |
482 | { | |
483 | struct zatm_dev *zatm_dev; | |
484 | struct zatm_vcc *zatm_vcc; | |
485 | unsigned long flags; | |
486 | unsigned short chan; | |
487 | int cells; | |
488 | ||
489 | DPRINTK("open_rx_first (0x%x)\n",inb_p(0xc053)); | |
490 | zatm_dev = ZATM_DEV(vcc->dev); | |
491 | zatm_vcc = ZATM_VCC(vcc); | |
492 | zatm_vcc->rx_chan = 0; | |
493 | if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0; | |
494 | if (vcc->qos.aal == ATM_AAL5) { | |
495 | if (vcc->qos.rxtp.max_sdu > 65464) | |
496 | vcc->qos.rxtp.max_sdu = 65464; | |
497 | /* fix this - we may want to receive 64kB SDUs | |
498 | later */ | |
6a19309d JL |
499 | cells = DIV_ROUND_UP(vcc->qos.rxtp.max_sdu + ATM_AAL5_TRAILER, |
500 | ATM_CELL_PAYLOAD); | |
1da177e4 LT |
501 | zatm_vcc->pool = pool_index(cells*ATM_CELL_PAYLOAD); |
502 | } | |
503 | else { | |
504 | cells = 1; | |
505 | zatm_vcc->pool = ZATM_AAL0_POOL; | |
506 | } | |
507 | if (zatm_vcc->pool < 0) return -EMSGSIZE; | |
508 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
509 | zwait; | |
510 | zout(uPD98401_OPEN_CHAN,CMR); | |
511 | zwait; | |
512 | DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER)); | |
513 | chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT; | |
514 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
515 | DPRINTK("chan is %d\n",chan); | |
516 | if (!chan) return -EAGAIN; | |
517 | use_pool(vcc->dev,zatm_vcc->pool); | |
518 | DPRINTK("pool %d\n",zatm_vcc->pool); | |
519 | /* set up VC descriptor */ | |
520 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
521 | zpokel(zatm_dev,zatm_vcc->pool << uPD98401_RXVC_POOL_SHIFT, | |
522 | chan*VC_SIZE/4); | |
523 | zpokel(zatm_dev,uPD98401_RXVC_OD | (vcc->qos.aal == ATM_AAL5 ? | |
524 | uPD98401_RXVC_AR : 0) | cells,chan*VC_SIZE/4+1); | |
525 | zpokel(zatm_dev,0,chan*VC_SIZE/4+2); | |
526 | zatm_vcc->rx_chan = chan; | |
527 | zatm_dev->rx_map[chan] = vcc; | |
528 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
529 | return 0; | |
530 | } | |
531 | ||
532 | ||
533 | static int open_rx_second(struct atm_vcc *vcc) | |
534 | { | |
535 | struct zatm_dev *zatm_dev; | |
536 | struct zatm_vcc *zatm_vcc; | |
537 | unsigned long flags; | |
538 | int pos,shift; | |
539 | ||
540 | DPRINTK("open_rx_second (0x%x)\n",inb_p(0xc053)); | |
541 | zatm_dev = ZATM_DEV(vcc->dev); | |
542 | zatm_vcc = ZATM_VCC(vcc); | |
543 | if (!zatm_vcc->rx_chan) return 0; | |
544 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
545 | /* should also handle VPI @@@ */ | |
546 | pos = vcc->vci >> 1; | |
547 | shift = (1-(vcc->vci & 1)) << 4; | |
548 | zpokel(zatm_dev,(zpeekl(zatm_dev,pos) & ~(0xffff << shift)) | | |
549 | ((zatm_vcc->rx_chan | uPD98401_RXLT_ENBL) << shift),pos); | |
550 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
551 | return 0; | |
552 | } | |
553 | ||
554 | ||
555 | static void close_rx(struct atm_vcc *vcc) | |
556 | { | |
557 | struct zatm_dev *zatm_dev; | |
558 | struct zatm_vcc *zatm_vcc; | |
559 | unsigned long flags; | |
560 | int pos,shift; | |
561 | ||
562 | zatm_vcc = ZATM_VCC(vcc); | |
563 | zatm_dev = ZATM_DEV(vcc->dev); | |
564 | if (!zatm_vcc->rx_chan) return; | |
565 | DPRINTK("close_rx\n"); | |
566 | /* disable receiver */ | |
567 | if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) { | |
568 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
569 | pos = vcc->vci >> 1; | |
570 | shift = (1-(vcc->vci & 1)) << 4; | |
571 | zpokel(zatm_dev,zpeekl(zatm_dev,pos) & ~(0xffff << shift),pos); | |
572 | zwait; | |
573 | zout(uPD98401_NOP,CMR); | |
574 | zwait; | |
575 | zout(uPD98401_NOP,CMR); | |
576 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
577 | } | |
578 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
579 | zwait; | |
580 | zout(uPD98401_DEACT_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan << | |
581 | uPD98401_CHAN_ADDR_SHIFT),CMR); | |
582 | zwait; | |
583 | udelay(10); /* why oh why ... ? */ | |
584 | zout(uPD98401_CLOSE_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan << | |
585 | uPD98401_CHAN_ADDR_SHIFT),CMR); | |
586 | zwait; | |
587 | if (!(zin(CMR) & uPD98401_CHAN_ADDR)) | |
588 | printk(KERN_CRIT DEV_LABEL "(itf %d): can't close RX channel " | |
589 | "%d\n",vcc->dev->number,zatm_vcc->rx_chan); | |
590 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
591 | zatm_dev->rx_map[zatm_vcc->rx_chan] = NULL; | |
592 | zatm_vcc->rx_chan = 0; | |
593 | unuse_pool(vcc->dev,zatm_vcc->pool); | |
594 | } | |
595 | ||
596 | ||
597 | static int start_rx(struct atm_dev *dev) | |
598 | { | |
599 | struct zatm_dev *zatm_dev; | |
600 | int size,i; | |
601 | ||
602 | DPRINTK("start_rx\n"); | |
603 | zatm_dev = ZATM_DEV(dev); | |
604 | size = sizeof(struct atm_vcc *)*zatm_dev->chans; | |
0c1cca1d | 605 | zatm_dev->rx_map = kzalloc(size,GFP_KERNEL); |
1da177e4 | 606 | if (!zatm_dev->rx_map) return -ENOMEM; |
1da177e4 LT |
607 | /* set VPI/VCI split (use all VCIs and give what's left to VPIs) */ |
608 | zpokel(zatm_dev,(1 << dev->ci_range.vci_bits)-1,uPD98401_VRR); | |
609 | /* prepare free buffer pools */ | |
610 | for (i = 0; i <= ZATM_LAST_POOL; i++) { | |
611 | zatm_dev->pool_info[i].ref_count = 0; | |
612 | zatm_dev->pool_info[i].rqa_count = 0; | |
613 | zatm_dev->pool_info[i].rqu_count = 0; | |
614 | zatm_dev->pool_info[i].low_water = LOW_MARK; | |
615 | zatm_dev->pool_info[i].high_water = HIGH_MARK; | |
616 | zatm_dev->pool_info[i].offset = 0; | |
617 | zatm_dev->pool_info[i].next_off = 0; | |
618 | zatm_dev->pool_info[i].next_cnt = 0; | |
619 | zatm_dev->pool_info[i].next_thres = OFF_CNG_THRES; | |
620 | } | |
621 | return 0; | |
622 | } | |
623 | ||
624 | ||
625 | /*----------------------------------- TX ------------------------------------*/ | |
626 | ||
627 | ||
628 | static int do_tx(struct sk_buff *skb) | |
629 | { | |
630 | struct atm_vcc *vcc; | |
631 | struct zatm_dev *zatm_dev; | |
632 | struct zatm_vcc *zatm_vcc; | |
633 | u32 *dsc; | |
634 | unsigned long flags; | |
635 | ||
636 | EVENT("do_tx\n",0,0); | |
637 | DPRINTK("sending skb %p\n",skb); | |
638 | vcc = ATM_SKB(skb)->vcc; | |
639 | zatm_dev = ZATM_DEV(vcc->dev); | |
640 | zatm_vcc = ZATM_VCC(vcc); | |
641 | EVENT("iovcnt=%d\n",skb_shinfo(skb)->nr_frags,0); | |
642 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
643 | if (!skb_shinfo(skb)->nr_frags) { | |
644 | if (zatm_vcc->txing == RING_ENTRIES-1) { | |
645 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
646 | return RING_BUSY; | |
647 | } | |
648 | zatm_vcc->txing++; | |
649 | dsc = zatm_vcc->ring+zatm_vcc->ring_curr; | |
650 | zatm_vcc->ring_curr = (zatm_vcc->ring_curr+RING_WORDS) & | |
651 | (RING_ENTRIES*RING_WORDS-1); | |
652 | dsc[1] = 0; | |
653 | dsc[2] = skb->len; | |
654 | dsc[3] = virt_to_bus(skb->data); | |
655 | mb(); | |
656 | dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP | uPD98401_TXPD_SM | |
657 | | (vcc->qos.aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 | | |
658 | (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ? | |
659 | uPD98401_CLPM_1 : uPD98401_CLPM_0)); | |
660 | EVENT("dsc (0x%lx)\n",(unsigned long) dsc,0); | |
661 | } | |
662 | else { | |
663 | printk("NONONONOO!!!!\n"); | |
664 | dsc = NULL; | |
665 | #if 0 | |
666 | u32 *put; | |
667 | int i; | |
668 | ||
79a34648 JJ |
669 | dsc = kmalloc(uPD98401_TXPD_SIZE * 2 + |
670 | uPD98401_TXBD_SIZE * ATM_SKB(skb)->iovcnt, GFP_ATOMIC); | |
1da177e4 | 671 | if (!dsc) { |
79a34648 JJ |
672 | if (vcc->pop) |
673 | vcc->pop(vcc, skb); | |
674 | else | |
675 | dev_kfree_skb_irq(skb); | |
1da177e4 LT |
676 | return -EAGAIN; |
677 | } | |
678 | /* @@@ should check alignment */ | |
679 | put = dsc+8; | |
680 | dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP | | |
681 | (vcc->aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 | | |
682 | (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ? | |
683 | uPD98401_CLPM_1 : uPD98401_CLPM_0)); | |
684 | dsc[1] = 0; | |
79a34648 | 685 | dsc[2] = ATM_SKB(skb)->iovcnt * uPD98401_TXBD_SIZE; |
1da177e4 LT |
686 | dsc[3] = virt_to_bus(put); |
687 | for (i = 0; i < ATM_SKB(skb)->iovcnt; i++) { | |
688 | *put++ = ((struct iovec *) skb->data)[i].iov_len; | |
689 | *put++ = virt_to_bus(((struct iovec *) | |
690 | skb->data)[i].iov_base); | |
691 | } | |
692 | put[-2] |= uPD98401_TXBD_LAST; | |
693 | #endif | |
694 | } | |
695 | ZATM_PRV_DSC(skb) = dsc; | |
696 | skb_queue_tail(&zatm_vcc->tx_queue,skb); | |
697 | DPRINTK("QRP=0x%08lx\n",zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+ | |
698 | uPD98401_TXVC_QRP)); | |
699 | zwait; | |
700 | zout(uPD98401_TX_READY | (zatm_vcc->tx_chan << | |
701 | uPD98401_CHAN_ADDR_SHIFT),CMR); | |
702 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
703 | EVENT("done\n",0,0); | |
704 | return 0; | |
705 | } | |
706 | ||
707 | ||
708 | static inline void dequeue_tx(struct atm_vcc *vcc) | |
709 | { | |
710 | struct zatm_vcc *zatm_vcc; | |
711 | struct sk_buff *skb; | |
712 | ||
713 | EVENT("dequeue_tx\n",0,0); | |
714 | zatm_vcc = ZATM_VCC(vcc); | |
715 | skb = skb_dequeue(&zatm_vcc->tx_queue); | |
716 | if (!skb) { | |
717 | printk(KERN_CRIT DEV_LABEL "(itf %d): dequeue_tx but not " | |
718 | "txing\n",vcc->dev->number); | |
719 | return; | |
720 | } | |
721 | #if 0 /* @@@ would fail on CLP */ | |
722 | if (*ZATM_PRV_DSC(skb) != (uPD98401_TXPD_V | uPD98401_TXPD_DP | | |
723 | uPD98401_TXPD_SM | uPD98401_TXPD_AAL5)) printk("@#*$!!!! (%08x)\n", | |
724 | *ZATM_PRV_DSC(skb)); | |
725 | #endif | |
726 | *ZATM_PRV_DSC(skb) = 0; /* mark as invalid */ | |
727 | zatm_vcc->txing--; | |
728 | if (vcc->pop) vcc->pop(vcc,skb); | |
729 | else dev_kfree_skb_irq(skb); | |
730 | while ((skb = skb_dequeue(&zatm_vcc->backlog))) | |
731 | if (do_tx(skb) == RING_BUSY) { | |
732 | skb_queue_head(&zatm_vcc->backlog,skb); | |
733 | break; | |
734 | } | |
735 | atomic_inc(&vcc->stats->tx); | |
736 | wake_up(&zatm_vcc->tx_wait); | |
737 | } | |
738 | ||
739 | ||
740 | static void poll_tx(struct atm_dev *dev,int mbx) | |
741 | { | |
742 | struct zatm_dev *zatm_dev; | |
743 | unsigned long pos; | |
744 | u32 x; | |
745 | ||
746 | EVENT("poll_tx\n",0,0); | |
747 | zatm_dev = ZATM_DEV(dev); | |
748 | pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx)); | |
749 | while (x = zin(MWA(mbx)), (pos & 0xffff) != x) { | |
750 | int chan; | |
751 | ||
752 | #if 1 | |
753 | u32 data,*addr; | |
754 | ||
755 | EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x); | |
756 | addr = (u32 *) pos; | |
757 | data = *addr; | |
758 | chan = (data & uPD98401_TXI_CONN) >> uPD98401_TXI_CONN_SHIFT; | |
759 | EVENT("addr = 0x%lx, data = 0x%08x,",(unsigned long) addr, | |
760 | data); | |
761 | EVENT("chan = %d\n",chan,0); | |
762 | #else | |
763 | NO ! | |
764 | chan = (zatm_dev->mbx_start[mbx][pos >> 2] & uPD98401_TXI_CONN) | |
765 | >> uPD98401_TXI_CONN_SHIFT; | |
766 | #endif | |
767 | if (chan < zatm_dev->chans && zatm_dev->tx_map[chan]) | |
768 | dequeue_tx(zatm_dev->tx_map[chan]); | |
769 | else { | |
770 | printk(KERN_CRIT DEV_LABEL "(itf %d): TX indication " | |
771 | "for non-existing channel %d\n",dev->number,chan); | |
772 | event_dump(); | |
773 | } | |
774 | if (((pos += 4) & 0xffff) == zatm_dev->mbx_end[mbx]) | |
775 | pos = zatm_dev->mbx_start[mbx]; | |
776 | } | |
777 | zout(pos & 0xffff,MTA(mbx)); | |
778 | } | |
779 | ||
780 | ||
781 | /* | |
782 | * BUG BUG BUG: Doesn't handle "new-style" rate specification yet. | |
783 | */ | |
784 | ||
785 | static int alloc_shaper(struct atm_dev *dev,int *pcr,int min,int max,int ubr) | |
786 | { | |
787 | struct zatm_dev *zatm_dev; | |
788 | unsigned long flags; | |
789 | unsigned long i,m,c; | |
790 | int shaper; | |
791 | ||
792 | DPRINTK("alloc_shaper (min = %d, max = %d)\n",min,max); | |
793 | zatm_dev = ZATM_DEV(dev); | |
794 | if (!zatm_dev->free_shapers) return -EAGAIN; | |
795 | for (shaper = 0; !((zatm_dev->free_shapers >> shaper) & 1); shaper++); | |
796 | zatm_dev->free_shapers &= ~1 << shaper; | |
797 | if (ubr) { | |
798 | c = 5; | |
799 | i = m = 1; | |
800 | zatm_dev->ubr_ref_cnt++; | |
801 | zatm_dev->ubr = shaper; | |
3e0c0ac8 | 802 | *pcr = 0; |
1da177e4 LT |
803 | } |
804 | else { | |
805 | if (min) { | |
806 | if (min <= 255) { | |
807 | i = min; | |
808 | m = ATM_OC3_PCR; | |
809 | } | |
810 | else { | |
811 | i = 255; | |
812 | m = ATM_OC3_PCR*255/min; | |
813 | } | |
814 | } | |
815 | else { | |
816 | if (max > zatm_dev->tx_bw) max = zatm_dev->tx_bw; | |
817 | if (max <= 255) { | |
818 | i = max; | |
819 | m = ATM_OC3_PCR; | |
820 | } | |
821 | else { | |
822 | i = 255; | |
6a19309d | 823 | m = DIV_ROUND_UP(ATM_OC3_PCR*255, max); |
1da177e4 LT |
824 | } |
825 | } | |
826 | if (i > m) { | |
827 | printk(KERN_CRIT DEV_LABEL "shaper algorithm botched " | |
828 | "[%d,%d] -> i=%ld,m=%ld\n",min,max,i,m); | |
829 | m = i; | |
830 | } | |
831 | *pcr = i*ATM_OC3_PCR/m; | |
832 | c = 20; /* @@@ should use max_cdv ! */ | |
833 | if ((min && *pcr < min) || (max && *pcr > max)) return -EINVAL; | |
834 | if (zatm_dev->tx_bw < *pcr) return -EAGAIN; | |
835 | zatm_dev->tx_bw -= *pcr; | |
836 | } | |
837 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
838 | DPRINTK("i = %d, m = %d, PCR = %d\n",i,m,*pcr); | |
839 | zpokel(zatm_dev,(i << uPD98401_IM_I_SHIFT) | m,uPD98401_IM(shaper)); | |
840 | zpokel(zatm_dev,c << uPD98401_PC_C_SHIFT,uPD98401_PC(shaper)); | |
841 | zpokel(zatm_dev,0,uPD98401_X(shaper)); | |
842 | zpokel(zatm_dev,0,uPD98401_Y(shaper)); | |
843 | zpokel(zatm_dev,uPD98401_PS_E,uPD98401_PS(shaper)); | |
844 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
845 | return shaper; | |
846 | } | |
847 | ||
848 | ||
849 | static void dealloc_shaper(struct atm_dev *dev,int shaper) | |
850 | { | |
851 | struct zatm_dev *zatm_dev; | |
852 | unsigned long flags; | |
853 | ||
854 | zatm_dev = ZATM_DEV(dev); | |
855 | if (shaper == zatm_dev->ubr) { | |
856 | if (--zatm_dev->ubr_ref_cnt) return; | |
857 | zatm_dev->ubr = -1; | |
858 | } | |
859 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
860 | zpokel(zatm_dev,zpeekl(zatm_dev,uPD98401_PS(shaper)) & ~uPD98401_PS_E, | |
861 | uPD98401_PS(shaper)); | |
862 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
863 | zatm_dev->free_shapers |= 1 << shaper; | |
864 | } | |
865 | ||
866 | ||
867 | static void close_tx(struct atm_vcc *vcc) | |
868 | { | |
869 | struct zatm_dev *zatm_dev; | |
870 | struct zatm_vcc *zatm_vcc; | |
871 | unsigned long flags; | |
872 | int chan; | |
873 | ||
874 | zatm_vcc = ZATM_VCC(vcc); | |
875 | zatm_dev = ZATM_DEV(vcc->dev); | |
876 | chan = zatm_vcc->tx_chan; | |
877 | if (!chan) return; | |
878 | DPRINTK("close_tx\n"); | |
879 | if (skb_peek(&zatm_vcc->backlog)) { | |
880 | printk("waiting for backlog to drain ...\n"); | |
881 | event_dump(); | |
882 | wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->backlog)); | |
883 | } | |
884 | if (skb_peek(&zatm_vcc->tx_queue)) { | |
885 | printk("waiting for TX queue to drain ...\n"); | |
886 | event_dump(); | |
887 | wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->tx_queue)); | |
888 | } | |
889 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
890 | #if 0 | |
891 | zwait; | |
892 | zout(uPD98401_DEACT_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR); | |
893 | #endif | |
894 | zwait; | |
895 | zout(uPD98401_CLOSE_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR); | |
896 | zwait; | |
897 | if (!(zin(CMR) & uPD98401_CHAN_ADDR)) | |
898 | printk(KERN_CRIT DEV_LABEL "(itf %d): can't close TX channel " | |
899 | "%d\n",vcc->dev->number,chan); | |
900 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
901 | zatm_vcc->tx_chan = 0; | |
902 | zatm_dev->tx_map[chan] = NULL; | |
903 | if (zatm_vcc->shaper != zatm_dev->ubr) { | |
904 | zatm_dev->tx_bw += vcc->qos.txtp.min_pcr; | |
905 | dealloc_shaper(vcc->dev,zatm_vcc->shaper); | |
906 | } | |
a2c1aa54 | 907 | kfree(zatm_vcc->ring); |
1da177e4 LT |
908 | } |
909 | ||
910 | ||
911 | static int open_tx_first(struct atm_vcc *vcc) | |
912 | { | |
913 | struct zatm_dev *zatm_dev; | |
914 | struct zatm_vcc *zatm_vcc; | |
915 | unsigned long flags; | |
916 | u32 *loop; | |
917 | unsigned short chan; | |
a6343afb | 918 | int unlimited; |
1da177e4 LT |
919 | |
920 | DPRINTK("open_tx_first\n"); | |
921 | zatm_dev = ZATM_DEV(vcc->dev); | |
922 | zatm_vcc = ZATM_VCC(vcc); | |
923 | zatm_vcc->tx_chan = 0; | |
924 | if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0; | |
925 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
926 | zwait; | |
927 | zout(uPD98401_OPEN_CHAN,CMR); | |
928 | zwait; | |
929 | DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER)); | |
930 | chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT; | |
931 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
932 | DPRINTK("chan is %d\n",chan); | |
933 | if (!chan) return -EAGAIN; | |
934 | unlimited = vcc->qos.txtp.traffic_class == ATM_UBR && | |
935 | (!vcc->qos.txtp.max_pcr || vcc->qos.txtp.max_pcr == ATM_MAX_PCR || | |
936 | vcc->qos.txtp.max_pcr >= ATM_OC3_PCR); | |
937 | if (unlimited && zatm_dev->ubr != -1) zatm_vcc->shaper = zatm_dev->ubr; | |
938 | else { | |
a6343afb JG |
939 | int uninitialized_var(pcr); |
940 | ||
1da177e4 LT |
941 | if (unlimited) vcc->qos.txtp.max_sdu = ATM_MAX_AAL5_PDU; |
942 | if ((zatm_vcc->shaper = alloc_shaper(vcc->dev,&pcr, | |
943 | vcc->qos.txtp.min_pcr,vcc->qos.txtp.max_pcr,unlimited)) | |
944 | < 0) { | |
945 | close_tx(vcc); | |
946 | return zatm_vcc->shaper; | |
947 | } | |
948 | if (pcr > ATM_OC3_PCR) pcr = ATM_OC3_PCR; | |
949 | vcc->qos.txtp.min_pcr = vcc->qos.txtp.max_pcr = pcr; | |
950 | } | |
951 | zatm_vcc->tx_chan = chan; | |
952 | skb_queue_head_init(&zatm_vcc->tx_queue); | |
953 | init_waitqueue_head(&zatm_vcc->tx_wait); | |
954 | /* initialize ring */ | |
0c1cca1d | 955 | zatm_vcc->ring = kzalloc(RING_SIZE,GFP_KERNEL); |
1da177e4 | 956 | if (!zatm_vcc->ring) return -ENOMEM; |
1da177e4 LT |
957 | loop = zatm_vcc->ring+RING_ENTRIES*RING_WORDS; |
958 | loop[0] = uPD98401_TXPD_V; | |
959 | loop[1] = loop[2] = 0; | |
960 | loop[3] = virt_to_bus(zatm_vcc->ring); | |
961 | zatm_vcc->ring_curr = 0; | |
962 | zatm_vcc->txing = 0; | |
963 | skb_queue_head_init(&zatm_vcc->backlog); | |
964 | zpokel(zatm_dev,virt_to_bus(zatm_vcc->ring), | |
965 | chan*VC_SIZE/4+uPD98401_TXVC_QRP); | |
966 | return 0; | |
967 | } | |
968 | ||
969 | ||
970 | static int open_tx_second(struct atm_vcc *vcc) | |
971 | { | |
972 | struct zatm_dev *zatm_dev; | |
973 | struct zatm_vcc *zatm_vcc; | |
974 | unsigned long flags; | |
975 | ||
976 | DPRINTK("open_tx_second\n"); | |
977 | zatm_dev = ZATM_DEV(vcc->dev); | |
978 | zatm_vcc = ZATM_VCC(vcc); | |
979 | if (!zatm_vcc->tx_chan) return 0; | |
980 | /* set up VC descriptor */ | |
981 | spin_lock_irqsave(&zatm_dev->lock, flags); | |
982 | zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4); | |
983 | zpokel(zatm_dev,uPD98401_TXVC_L | (zatm_vcc->shaper << | |
984 | uPD98401_TXVC_SHP_SHIFT) | (vcc->vpi << uPD98401_TXVC_VPI_SHIFT) | | |
985 | vcc->vci,zatm_vcc->tx_chan*VC_SIZE/4+1); | |
986 | zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4+2); | |
987 | spin_unlock_irqrestore(&zatm_dev->lock, flags); | |
988 | zatm_dev->tx_map[zatm_vcc->tx_chan] = vcc; | |
989 | return 0; | |
990 | } | |
991 | ||
992 | ||
993 | static int start_tx(struct atm_dev *dev) | |
994 | { | |
995 | struct zatm_dev *zatm_dev; | |
996 | int i; | |
997 | ||
998 | DPRINTK("start_tx\n"); | |
999 | zatm_dev = ZATM_DEV(dev); | |
5cbded58 | 1000 | zatm_dev->tx_map = kmalloc(sizeof(struct atm_vcc *)* |
1da177e4 LT |
1001 | zatm_dev->chans,GFP_KERNEL); |
1002 | if (!zatm_dev->tx_map) return -ENOMEM; | |
1003 | zatm_dev->tx_bw = ATM_OC3_PCR; | |
1004 | zatm_dev->free_shapers = (1 << NR_SHAPERS)-1; | |
1005 | zatm_dev->ubr = -1; | |
1006 | zatm_dev->ubr_ref_cnt = 0; | |
1007 | /* initialize shapers */ | |
1008 | for (i = 0; i < NR_SHAPERS; i++) zpokel(zatm_dev,0,uPD98401_PS(i)); | |
1009 | return 0; | |
1010 | } | |
1011 | ||
1012 | ||
1013 | /*------------------------------- interrupts --------------------------------*/ | |
1014 | ||
1015 | ||
7d12e780 | 1016 | static irqreturn_t zatm_int(int irq,void *dev_id) |
1da177e4 LT |
1017 | { |
1018 | struct atm_dev *dev; | |
1019 | struct zatm_dev *zatm_dev; | |
1020 | u32 reason; | |
1021 | int handled = 0; | |
1022 | ||
1023 | dev = dev_id; | |
1024 | zatm_dev = ZATM_DEV(dev); | |
1025 | while ((reason = zin(GSR))) { | |
1026 | handled = 1; | |
1027 | EVENT("reason 0x%x\n",reason,0); | |
1028 | if (reason & uPD98401_INT_PI) { | |
1029 | EVENT("PHY int\n",0,0); | |
1030 | dev->phy->interrupt(dev); | |
1031 | } | |
1032 | if (reason & uPD98401_INT_RQA) { | |
1033 | unsigned long pools; | |
1034 | int i; | |
1035 | ||
1036 | pools = zin(RQA); | |
1037 | EVENT("RQA (0x%08x)\n",pools,0); | |
1038 | for (i = 0; pools; i++) { | |
1039 | if (pools & 1) { | |
1040 | refill_pool(dev,i); | |
1041 | zatm_dev->pool_info[i].rqa_count++; | |
1042 | } | |
1043 | pools >>= 1; | |
1044 | } | |
1045 | } | |
1046 | if (reason & uPD98401_INT_RQU) { | |
1047 | unsigned long pools; | |
1048 | int i; | |
1049 | pools = zin(RQU); | |
1050 | printk(KERN_WARNING DEV_LABEL "(itf %d): RQU 0x%08lx\n", | |
1051 | dev->number,pools); | |
1052 | event_dump(); | |
1053 | for (i = 0; pools; i++) { | |
1054 | if (pools & 1) { | |
1055 | refill_pool(dev,i); | |
1056 | zatm_dev->pool_info[i].rqu_count++; | |
1057 | } | |
1058 | pools >>= 1; | |
1059 | } | |
1060 | } | |
1061 | /* don't handle RD */ | |
1062 | if (reason & uPD98401_INT_SPE) | |
1063 | printk(KERN_ALERT DEV_LABEL "(itf %d): system parity " | |
1064 | "error at 0x%08x\n",dev->number,zin(ADDR)); | |
1065 | if (reason & uPD98401_INT_CPE) | |
1066 | printk(KERN_ALERT DEV_LABEL "(itf %d): control memory " | |
1067 | "parity error at 0x%08x\n",dev->number,zin(ADDR)); | |
1068 | if (reason & uPD98401_INT_SBE) { | |
1069 | printk(KERN_ALERT DEV_LABEL "(itf %d): system bus " | |
1070 | "error at 0x%08x\n",dev->number,zin(ADDR)); | |
1071 | event_dump(); | |
1072 | } | |
1073 | /* don't handle IND */ | |
1074 | if (reason & uPD98401_INT_MF) { | |
1075 | printk(KERN_CRIT DEV_LABEL "(itf %d): mailbox full " | |
1076 | "(0x%x)\n",dev->number,(reason & uPD98401_INT_MF) | |
1077 | >> uPD98401_INT_MF_SHIFT); | |
1078 | event_dump(); | |
1079 | /* @@@ should try to recover */ | |
1080 | } | |
1081 | if (reason & uPD98401_INT_MM) { | |
1082 | if (reason & 1) poll_rx(dev,0); | |
1083 | if (reason & 2) poll_rx(dev,1); | |
1084 | if (reason & 4) poll_tx(dev,2); | |
1085 | if (reason & 8) poll_tx(dev,3); | |
1086 | } | |
1087 | /* @@@ handle RCRn */ | |
1088 | } | |
1089 | return IRQ_RETVAL(handled); | |
1090 | } | |
1091 | ||
1092 | ||
1093 | /*----------------------------- (E)EPROM access -----------------------------*/ | |
1094 | ||
1095 | ||
1096 | static void __devinit eprom_set(struct zatm_dev *zatm_dev,unsigned long value, | |
1097 | unsigned short cmd) | |
1098 | { | |
1099 | int error; | |
1100 | ||
1101 | if ((error = pci_write_config_dword(zatm_dev->pci_dev,cmd,value))) | |
1102 | printk(KERN_ERR DEV_LABEL ": PCI write failed (0x%02x)\n", | |
1103 | error); | |
1104 | } | |
1105 | ||
1106 | ||
1107 | static unsigned long __devinit eprom_get(struct zatm_dev *zatm_dev, | |
1108 | 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 | ||
1120 | static void __devinit eprom_put_bits(struct zatm_dev *zatm_dev, | |
1121 | unsigned long data,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 | ||
1135 | static void __devinit eprom_get_byte(struct zatm_dev *zatm_dev, | |
1136 | unsigned char *byte,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 | ||
1151 | static unsigned char __devinit eprom_try_esi(struct atm_dev *dev, | |
1152 | unsigned short cmd,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 | ||
1172 | static void __devinit 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 | ||
ebf88a9e | 1182 | static int __devinit zatm_init(struct atm_dev *dev) |
1da177e4 LT |
1183 | { |
1184 | struct zatm_dev *zatm_dev; | |
1185 | struct pci_dev *pci_dev; | |
1186 | unsigned short command; | |
1da177e4 LT |
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; | |
44c10138 | 1196 | if ((error = pci_read_config_word(pci_dev,PCI_COMMAND,&command))) { |
1da177e4 LT |
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,", | |
44c10138 | 1209 | dev->number,pci_dev->revision,zatm_dev->base,zatm_dev->irq); |
1da177e4 LT |
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 | ||
ebf88a9e | 1259 | static int __devinit zatm_start(struct atm_dev *dev) |
1da177e4 | 1260 | { |
4aa49d13 FR |
1261 | struct zatm_dev *zatm_dev = ZATM_DEV(dev); |
1262 | struct pci_dev *pdev = zatm_dev->pci_dev; | |
1da177e4 LT |
1263 | unsigned long curr; |
1264 | int pools,vccs,rx; | |
4aa49d13 | 1265 | int error, i, ld; |
1da177e4 LT |
1266 | |
1267 | DPRINTK("zatm_start\n"); | |
1da177e4 | 1268 | zatm_dev->rx_map = zatm_dev->tx_map = NULL; |
4aa49d13 FR |
1269 | for (i = 0; i < NR_MBX; i++) |
1270 | zatm_dev->mbx_start[i] = 0; | |
dace1453 | 1271 | error = request_irq(zatm_dev->irq, zatm_int, IRQF_SHARED, DEV_LABEL, dev); |
4aa49d13 FR |
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; | |
1da177e4 | 1276 | } |
1da177e4 LT |
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 */ | |
4aa49d13 FR |
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; | |
1da177e4 | 1324 | } |
4aa49d13 FR |
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 | } | |
1da177e4 | 1336 | error = start_tx(dev); |
4aa49d13 FR |
1337 | if (error) |
1338 | goto out; | |
1da177e4 | 1339 | error = start_rx(dev); |
4aa49d13 FR |
1340 | if (error) |
1341 | goto out_tx; | |
1da177e4 | 1342 | error = dev->phy->start(dev); |
4aa49d13 FR |
1343 | if (error) |
1344 | goto out_rx; | |
1da177e4 LT |
1345 | zout(0xffffffff,IMR); /* enable interrupts */ |
1346 | /* enable TX & RX */ | |
1347 | zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR); | |
4aa49d13 FR |
1348 | done: |
1349 | return error; | |
1350 | ||
1351 | out_rx: | |
a2c1aa54 | 1352 | kfree(zatm_dev->rx_map); |
4aa49d13 | 1353 | out_tx: |
a2c1aa54 | 1354 | kfree(zatm_dev->tx_map); |
4aa49d13 FR |
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 | } | |
1da177e4 | 1361 | free_irq(zatm_dev->irq, dev); |
4aa49d13 | 1362 | goto done; |
1da177e4 LT |
1363 | } |
1364 | ||
1365 | ||
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 | ||
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 | ||
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 | ||
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 | ||
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 | ||
1519 | static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname, | |
b7058842 | 1520 | void __user *optval,unsigned int optlen) |
1da177e4 LT |
1521 | { |
1522 | return -EINVAL; | |
1523 | } | |
1524 | ||
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 | ||
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 | ||
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 | ||
1586 | static int __devinit 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 | ||
5cbded58 | 1593 | zatm_dev = kmalloc(sizeof(*zatm_dev), GFP_KERNEL); |
1da177e4 LT |
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, &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[] __devinitdata = { | |
1639 | { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1221, | |
1640 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, ZATM_COPPER }, | |
1641 | { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1225, | |
1642 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, | |
1643 | { 0, } | |
1644 | }; | |
1645 | MODULE_DEVICE_TABLE(pci, zatm_pci_tbl); | |
1646 | ||
1647 | static struct pci_driver zatm_driver = { | |
1648 | .name = DEV_LABEL, | |
1649 | .id_table = zatm_pci_tbl, | |
1650 | .probe = zatm_init_one, | |
1651 | }; | |
1652 | ||
1653 | static int __init zatm_init_module(void) | |
1654 | { | |
1655 | return pci_register_driver(&zatm_driver); | |
1656 | } | |
1657 | ||
1658 | module_init(zatm_init_module); | |
1659 | /* module_exit not defined so not unloadable */ |