Root/
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/dma-mapping.h> |
20 | #include <linux/atm_zatm.h> |
21 | #include <linux/capability.h> |
22 | #include <linux/bitops.h> |
23 | #include <linux/wait.h> |
24 | #include <linux/slab.h> |
25 | #include <asm/byteorder.h> |
26 | #include <asm/system.h> |
27 | #include <asm/string.h> |
28 | #include <asm/io.h> |
29 | #include <asm/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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
256 | static void drain_free(struct atm_dev *dev,int pool) |
257 | { |
258 | skb_queue_purge(&ZATM_DEV(dev)->pool[pool]); |
259 | } |
260 | |
261 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
1097 | static void __devinit 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 | |
1108 | static unsigned long __devinit eprom_get(struct zatm_dev *zatm_dev, |
1109 | unsigned short cmd) |
1110 | { |
1111 | unsigned int value; |
1112 | int error; |
1113 | |
1114 | if ((error = pci_read_config_dword(zatm_dev->pci_dev,cmd,&value))) |
1115 | printk(KERN_ERR DEV_LABEL ": PCI read failed (0x%02x)\n", |
1116 | error); |
1117 | return value; |
1118 | } |
1119 | |
1120 | |
1121 | static void __devinit eprom_put_bits(struct zatm_dev *zatm_dev, |
1122 | unsigned long data,int bits,unsigned short cmd) |
1123 | { |
1124 | unsigned long value; |
1125 | int i; |
1126 | |
1127 | for (i = bits-1; i >= 0; i--) { |
1128 | value = ZEPROM_CS | (((data >> i) & 1) ? ZEPROM_DI : 0); |
1129 | eprom_set(zatm_dev,value,cmd); |
1130 | eprom_set(zatm_dev,value | ZEPROM_SK,cmd); |
1131 | eprom_set(zatm_dev,value,cmd); |
1132 | } |
1133 | } |
1134 | |
1135 | |
1136 | static void __devinit eprom_get_byte(struct zatm_dev *zatm_dev, |
1137 | unsigned char *byte,unsigned short cmd) |
1138 | { |
1139 | int i; |
1140 | |
1141 | *byte = 0; |
1142 | for (i = 8; i; i--) { |
1143 | eprom_set(zatm_dev,ZEPROM_CS,cmd); |
1144 | eprom_set(zatm_dev,ZEPROM_CS | ZEPROM_SK,cmd); |
1145 | *byte <<= 1; |
1146 | if (eprom_get(zatm_dev,cmd) & ZEPROM_DO) *byte |= 1; |
1147 | eprom_set(zatm_dev,ZEPROM_CS,cmd); |
1148 | } |
1149 | } |
1150 | |
1151 | |
1152 | static unsigned char __devinit eprom_try_esi(struct atm_dev *dev, |
1153 | unsigned short cmd,int offset,int swap) |
1154 | { |
1155 | unsigned char buf[ZEPROM_SIZE]; |
1156 | struct zatm_dev *zatm_dev; |
1157 | int i; |
1158 | |
1159 | zatm_dev = ZATM_DEV(dev); |
1160 | for (i = 0; i < ZEPROM_SIZE; i += 2) { |
1161 | eprom_set(zatm_dev,ZEPROM_CS,cmd); /* select EPROM */ |
1162 | eprom_put_bits(zatm_dev,ZEPROM_CMD_READ,ZEPROM_CMD_LEN,cmd); |
1163 | eprom_put_bits(zatm_dev,i >> 1,ZEPROM_ADDR_LEN,cmd); |
1164 | eprom_get_byte(zatm_dev,buf+i+swap,cmd); |
1165 | eprom_get_byte(zatm_dev,buf+i+1-swap,cmd); |
1166 | eprom_set(zatm_dev,0,cmd); /* deselect EPROM */ |
1167 | } |
1168 | memcpy(dev->esi,buf+offset,ESI_LEN); |
1169 | return memcmp(dev->esi,"\0\0\0\0\0",ESI_LEN); /* assumes ESI_LEN == 6 */ |
1170 | } |
1171 | |
1172 | |
1173 | static void __devinit eprom_get_esi(struct atm_dev *dev) |
1174 | { |
1175 | if (eprom_try_esi(dev,ZEPROM_V1_REG,ZEPROM_V1_ESI_OFF,1)) return; |
1176 | (void) eprom_try_esi(dev,ZEPROM_V2_REG,ZEPROM_V2_ESI_OFF,0); |
1177 | } |
1178 | |
1179 | |
1180 | /*--------------------------------- entries ---------------------------------*/ |
1181 | |
1182 | |
1183 | static int __devinit zatm_init(struct atm_dev *dev) |
1184 | { |
1185 | struct zatm_dev *zatm_dev; |
1186 | struct pci_dev *pci_dev; |
1187 | unsigned short command; |
1188 | int error,i,last; |
1189 | unsigned long t0,t1,t2; |
1190 | |
1191 | DPRINTK(">zatm_init\n"); |
1192 | zatm_dev = ZATM_DEV(dev); |
1193 | spin_lock_init(&zatm_dev->lock); |
1194 | pci_dev = zatm_dev->pci_dev; |
1195 | zatm_dev->base = pci_resource_start(pci_dev, 0); |
1196 | zatm_dev->irq = pci_dev->irq; |
1197 | if ((error = pci_read_config_word(pci_dev,PCI_COMMAND,&command))) { |
1198 | printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%02x\n", |
1199 | dev->number,error); |
1200 | return -EINVAL; |
1201 | } |
1202 | if ((error = pci_write_config_word(pci_dev,PCI_COMMAND, |
1203 | command | PCI_COMMAND_IO | PCI_COMMAND_MASTER))) { |
1204 | printk(KERN_ERR DEV_LABEL "(itf %d): can't enable IO (0x%02x)" |
1205 | "\n",dev->number,error); |
1206 | return -EIO; |
1207 | } |
1208 | eprom_get_esi(dev); |
1209 | printk(KERN_NOTICE DEV_LABEL "(itf %d): rev.%d,base=0x%x,irq=%d,", |
1210 | dev->number,pci_dev->revision,zatm_dev->base,zatm_dev->irq); |
1211 | /* reset uPD98401 */ |
1212 | zout(0,SWR); |
1213 | while (!(zin(GSR) & uPD98401_INT_IND)); |
1214 | zout(uPD98401_GMR_ONE /*uPD98401_BURST4*/,GMR); |
1215 | last = MAX_CRAM_SIZE; |
1216 | for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) { |
1217 | zpokel(zatm_dev,0x55555555,i); |
1218 | if (zpeekl(zatm_dev,i) != 0x55555555) last = i; |
1219 | else { |
1220 | zpokel(zatm_dev,0xAAAAAAAA,i); |
1221 | if (zpeekl(zatm_dev,i) != 0xAAAAAAAA) last = i; |
1222 | else zpokel(zatm_dev,i,i); |
1223 | } |
1224 | } |
1225 | for (i = 0; i < last; i += RAM_INCREMENT) |
1226 | if (zpeekl(zatm_dev,i) != i) break; |
1227 | zatm_dev->mem = i << 2; |
1228 | while (i) zpokel(zatm_dev,0,--i); |
1229 | /* reset again to rebuild memory pointers */ |
1230 | zout(0,SWR); |
1231 | while (!(zin(GSR) & uPD98401_INT_IND)); |
1232 | zout(uPD98401_GMR_ONE | uPD98401_BURST8 | uPD98401_BURST4 | |
1233 | uPD98401_BURST2 | uPD98401_GMR_PM | uPD98401_GMR_DR,GMR); |
1234 | /* TODO: should shrink allocation now */ |
1235 | printk("mem=%dkB,%s (",zatm_dev->mem >> 10,zatm_dev->copper ? "UTP" : |
1236 | "MMF"); |
1237 | for (i = 0; i < ESI_LEN; i++) |
1238 | printk("%02X%s",dev->esi[i],i == ESI_LEN-1 ? ")\n" : "-"); |
1239 | do { |
1240 | unsigned long flags; |
1241 | |
1242 | spin_lock_irqsave(&zatm_dev->lock, flags); |
1243 | t0 = zpeekl(zatm_dev,uPD98401_TSR); |
1244 | udelay(10); |
1245 | t1 = zpeekl(zatm_dev,uPD98401_TSR); |
1246 | udelay(1010); |
1247 | t2 = zpeekl(zatm_dev,uPD98401_TSR); |
1248 | spin_unlock_irqrestore(&zatm_dev->lock, flags); |
1249 | } |
1250 | while (t0 > t1 || t1 > t2); /* loop if wrapping ... */ |
1251 | zatm_dev->khz = t2-2*t1+t0; |
1252 | printk(KERN_NOTICE DEV_LABEL "(itf %d): uPD98401 %d.%d at %d.%03d " |
1253 | "MHz\n",dev->number, |
1254 | (zin(VER) & uPD98401_MAJOR) >> uPD98401_MAJOR_SHIFT, |
1255 | zin(VER) & uPD98401_MINOR,zatm_dev->khz/1000,zatm_dev->khz % 1000); |
1256 | return uPD98402_init(dev); |
1257 | } |
1258 | |
1259 | |
1260 | static int __devinit zatm_start(struct atm_dev *dev) |
1261 | { |
1262 | struct zatm_dev *zatm_dev = ZATM_DEV(dev); |
1263 | struct pci_dev *pdev = zatm_dev->pci_dev; |
1264 | unsigned long curr; |
1265 | int pools,vccs,rx; |
1266 | int error, i, ld; |
1267 | |
1268 | DPRINTK("zatm_start\n"); |
1269 | zatm_dev->rx_map = zatm_dev->tx_map = NULL; |
1270 | for (i = 0; i < NR_MBX; i++) |
1271 | zatm_dev->mbx_start[i] = 0; |
1272 | error = request_irq(zatm_dev->irq, zatm_int, IRQF_SHARED, DEV_LABEL, dev); |
1273 | if (error < 0) { |
1274 | printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n", |
1275 | dev->number,zatm_dev->irq); |
1276 | goto done; |
1277 | } |
1278 | /* define memory regions */ |
1279 | pools = NR_POOLS; |
1280 | if (NR_SHAPERS*SHAPER_SIZE > pools*POOL_SIZE) |
1281 | pools = NR_SHAPERS*SHAPER_SIZE/POOL_SIZE; |
1282 | vccs = (zatm_dev->mem-NR_SHAPERS*SHAPER_SIZE-pools*POOL_SIZE)/ |
1283 | (2*VC_SIZE+RX_SIZE); |
1284 | ld = -1; |
1285 | for (rx = 1; rx < vccs; rx <<= 1) ld++; |
1286 | dev->ci_range.vpi_bits = 0; /* @@@ no VPI for now */ |
1287 | dev->ci_range.vci_bits = ld; |
1288 | dev->link_rate = ATM_OC3_PCR; |
1289 | zatm_dev->chans = vccs; /* ??? */ |
1290 | curr = rx*RX_SIZE/4; |
1291 | DPRINTK("RX pool 0x%08lx\n",curr); |
1292 | zpokel(zatm_dev,curr,uPD98401_PMA); /* receive pool */ |
1293 | zatm_dev->pool_base = curr; |
1294 | curr += pools*POOL_SIZE/4; |
1295 | DPRINTK("Shapers 0x%08lx\n",curr); |
1296 | zpokel(zatm_dev,curr,uPD98401_SMA); /* shapers */ |
1297 | curr += NR_SHAPERS*SHAPER_SIZE/4; |
1298 | DPRINTK("Free 0x%08lx\n",curr); |
1299 | zpokel(zatm_dev,curr,uPD98401_TOS); /* free pool */ |
1300 | printk(KERN_INFO DEV_LABEL "(itf %d): %d shapers, %d pools, %d RX, " |
1301 | "%ld VCs\n",dev->number,NR_SHAPERS,pools,rx, |
1302 | (zatm_dev->mem-curr*4)/VC_SIZE); |
1303 | /* create mailboxes */ |
1304 | for (i = 0; i < NR_MBX; i++) { |
1305 | void *mbx; |
1306 | dma_addr_t mbx_dma; |
1307 | |
1308 | if (!mbx_entries[i]) |
1309 | continue; |
1310 | mbx = pci_alloc_consistent(pdev, 2*MBX_SIZE(i), &mbx_dma); |
1311 | if (!mbx) { |
1312 | error = -ENOMEM; |
1313 | goto out; |
1314 | } |
1315 | /* |
1316 | * Alignment provided by pci_alloc_consistent() isn't enough |
1317 | * for this device. |
1318 | */ |
1319 | if (((unsigned long)mbx ^ mbx_dma) & 0xffff) { |
1320 | printk(KERN_ERR DEV_LABEL "(itf %d): system " |
1321 | "bus incompatible with driver\n", dev->number); |
1322 | pci_free_consistent(pdev, 2*MBX_SIZE(i), mbx, mbx_dma); |
1323 | error = -ENODEV; |
1324 | goto out; |
1325 | } |
1326 | DPRINTK("mbx@0x%08lx-0x%08lx\n", mbx, mbx + MBX_SIZE(i)); |
1327 | zatm_dev->mbx_start[i] = (unsigned long)mbx; |
1328 | zatm_dev->mbx_dma[i] = mbx_dma; |
1329 | zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) & |
1330 | 0xffff; |
1331 | zout(mbx_dma >> 16, MSH(i)); |
1332 | zout(mbx_dma, MSL(i)); |
1333 | zout(zatm_dev->mbx_end[i], MBA(i)); |
1334 | zout((unsigned long)mbx & 0xffff, MTA(i)); |
1335 | zout((unsigned long)mbx & 0xffff, MWA(i)); |
1336 | } |
1337 | error = start_tx(dev); |
1338 | if (error) |
1339 | goto out; |
1340 | error = start_rx(dev); |
1341 | if (error) |
1342 | goto out_tx; |
1343 | error = dev->phy->start(dev); |
1344 | if (error) |
1345 | goto out_rx; |
1346 | zout(0xffffffff,IMR); /* enable interrupts */ |
1347 | /* enable TX & RX */ |
1348 | zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR); |
1349 | done: |
1350 | return error; |
1351 | |
1352 | out_rx: |
1353 | kfree(zatm_dev->rx_map); |
1354 | out_tx: |
1355 | kfree(zatm_dev->tx_map); |
1356 | out: |
1357 | while (i-- > 0) { |
1358 | pci_free_consistent(pdev, 2*MBX_SIZE(i), |
1359 | (void *)zatm_dev->mbx_start[i], |
1360 | zatm_dev->mbx_dma[i]); |
1361 | } |
1362 | free_irq(zatm_dev->irq, dev); |
1363 | goto done; |
1364 | } |
1365 | |
1366 | |
1367 | static void zatm_close(struct atm_vcc *vcc) |
1368 | { |
1369 | DPRINTK(">zatm_close\n"); |
1370 | if (!ZATM_VCC(vcc)) return; |
1371 | clear_bit(ATM_VF_READY,&vcc->flags); |
1372 | close_rx(vcc); |
1373 | EVENT("close_tx\n",0,0); |
1374 | close_tx(vcc); |
1375 | DPRINTK("zatm_close: done waiting\n"); |
1376 | /* deallocate memory */ |
1377 | kfree(ZATM_VCC(vcc)); |
1378 | vcc->dev_data = NULL; |
1379 | clear_bit(ATM_VF_ADDR,&vcc->flags); |
1380 | } |
1381 | |
1382 | |
1383 | static int zatm_open(struct atm_vcc *vcc) |
1384 | { |
1385 | struct zatm_dev *zatm_dev; |
1386 | struct zatm_vcc *zatm_vcc; |
1387 | short vpi = vcc->vpi; |
1388 | int vci = vcc->vci; |
1389 | int error; |
1390 | |
1391 | DPRINTK(">zatm_open\n"); |
1392 | zatm_dev = ZATM_DEV(vcc->dev); |
1393 | if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) |
1394 | vcc->dev_data = NULL; |
1395 | if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC) |
1396 | set_bit(ATM_VF_ADDR,&vcc->flags); |
1397 | if (vcc->qos.aal != ATM_AAL5) return -EINVAL; /* @@@ AAL0 */ |
1398 | DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi, |
1399 | vcc->vci); |
1400 | if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) { |
1401 | zatm_vcc = kmalloc(sizeof(struct zatm_vcc),GFP_KERNEL); |
1402 | if (!zatm_vcc) { |
1403 | clear_bit(ATM_VF_ADDR,&vcc->flags); |
1404 | return -ENOMEM; |
1405 | } |
1406 | vcc->dev_data = zatm_vcc; |
1407 | ZATM_VCC(vcc)->tx_chan = 0; /* for zatm_close after open_rx */ |
1408 | if ((error = open_rx_first(vcc))) { |
1409 | zatm_close(vcc); |
1410 | return error; |
1411 | } |
1412 | if ((error = open_tx_first(vcc))) { |
1413 | zatm_close(vcc); |
1414 | return error; |
1415 | } |
1416 | } |
1417 | if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0; |
1418 | if ((error = open_rx_second(vcc))) { |
1419 | zatm_close(vcc); |
1420 | return error; |
1421 | } |
1422 | if ((error = open_tx_second(vcc))) { |
1423 | zatm_close(vcc); |
1424 | return error; |
1425 | } |
1426 | set_bit(ATM_VF_READY,&vcc->flags); |
1427 | return 0; |
1428 | } |
1429 | |
1430 | |
1431 | static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags) |
1432 | { |
1433 | printk("Not yet implemented\n"); |
1434 | return -ENOSYS; |
1435 | /* @@@ */ |
1436 | } |
1437 | |
1438 | |
1439 | static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg) |
1440 | { |
1441 | struct zatm_dev *zatm_dev; |
1442 | unsigned long flags; |
1443 | |
1444 | zatm_dev = ZATM_DEV(dev); |
1445 | switch (cmd) { |
1446 | case ZATM_GETPOOLZ: |
1447 | if (!capable(CAP_NET_ADMIN)) return -EPERM; |
1448 | /* fall through */ |
1449 | case ZATM_GETPOOL: |
1450 | { |
1451 | struct zatm_pool_info info; |
1452 | int pool; |
1453 | |
1454 | if (get_user(pool, |
1455 | &((struct zatm_pool_req __user *) arg)->pool_num)) |
1456 | return -EFAULT; |
1457 | if (pool < 0 || pool > ZATM_LAST_POOL) |
1458 | return -EINVAL; |
1459 | spin_lock_irqsave(&zatm_dev->lock, flags); |
1460 | info = zatm_dev->pool_info[pool]; |
1461 | if (cmd == ZATM_GETPOOLZ) { |
1462 | zatm_dev->pool_info[pool].rqa_count = 0; |
1463 | zatm_dev->pool_info[pool].rqu_count = 0; |
1464 | } |
1465 | spin_unlock_irqrestore(&zatm_dev->lock, flags); |
1466 | return copy_to_user( |
1467 | &((struct zatm_pool_req __user *) arg)->info, |
1468 | &info,sizeof(info)) ? -EFAULT : 0; |
1469 | } |
1470 | case ZATM_SETPOOL: |
1471 | { |
1472 | struct zatm_pool_info info; |
1473 | int pool; |
1474 | |
1475 | if (!capable(CAP_NET_ADMIN)) return -EPERM; |
1476 | if (get_user(pool, |
1477 | &((struct zatm_pool_req __user *) arg)->pool_num)) |
1478 | return -EFAULT; |
1479 | if (pool < 0 || pool > ZATM_LAST_POOL) |
1480 | return -EINVAL; |
1481 | if (copy_from_user(&info, |
1482 | &((struct zatm_pool_req __user *) arg)->info, |
1483 | sizeof(info))) return -EFAULT; |
1484 | if (!info.low_water) |
1485 | info.low_water = zatm_dev-> |
1486 | pool_info[pool].low_water; |
1487 | if (!info.high_water) |
1488 | info.high_water = zatm_dev-> |
1489 | pool_info[pool].high_water; |
1490 | if (!info.next_thres) |
1491 | info.next_thres = zatm_dev-> |
1492 | pool_info[pool].next_thres; |
1493 | if (info.low_water >= info.high_water || |
1494 | info.low_water < 0) |
1495 | return -EINVAL; |
1496 | spin_lock_irqsave(&zatm_dev->lock, flags); |
1497 | zatm_dev->pool_info[pool].low_water = |
1498 | info.low_water; |
1499 | zatm_dev->pool_info[pool].high_water = |
1500 | info.high_water; |
1501 | zatm_dev->pool_info[pool].next_thres = |
1502 | info.next_thres; |
1503 | spin_unlock_irqrestore(&zatm_dev->lock, flags); |
1504 | return 0; |
1505 | } |
1506 | default: |
1507 | if (!dev->phy->ioctl) return -ENOIOCTLCMD; |
1508 | return dev->phy->ioctl(dev,cmd,arg); |
1509 | } |
1510 | } |
1511 | |
1512 | |
1513 | static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname, |
1514 | void __user *optval,int optlen) |
1515 | { |
1516 | return -EINVAL; |
1517 | } |
1518 | |
1519 | |
1520 | static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname, |
1521 | void __user *optval,unsigned int optlen) |
1522 | { |
1523 | return -EINVAL; |
1524 | } |
1525 | |
1526 | static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb) |
1527 | { |
1528 | int error; |
1529 | |
1530 | EVENT(">zatm_send 0x%lx\n",(unsigned long) skb,0); |
1531 | if (!ZATM_VCC(vcc)->tx_chan || !test_bit(ATM_VF_READY,&vcc->flags)) { |
1532 | if (vcc->pop) vcc->pop(vcc,skb); |
1533 | else dev_kfree_skb(skb); |
1534 | return -EINVAL; |
1535 | } |
1536 | if (!skb) { |
1537 | printk(KERN_CRIT "!skb in zatm_send ?\n"); |
1538 | if (vcc->pop) vcc->pop(vcc,skb); |
1539 | return -EINVAL; |
1540 | } |
1541 | ATM_SKB(skb)->vcc = vcc; |
1542 | error = do_tx(skb); |
1543 | if (error != RING_BUSY) return error; |
1544 | skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb); |
1545 | return 0; |
1546 | } |
1547 | |
1548 | |
1549 | static void zatm_phy_put(struct atm_dev *dev,unsigned char value, |
1550 | unsigned long addr) |
1551 | { |
1552 | struct zatm_dev *zatm_dev; |
1553 | |
1554 | zatm_dev = ZATM_DEV(dev); |
1555 | zwait; |
1556 | zout(value,CER); |
1557 | zout(uPD98401_IND_ACC | uPD98401_IA_B0 | |
1558 | (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR); |
1559 | } |
1560 | |
1561 | |
1562 | static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr) |
1563 | { |
1564 | struct zatm_dev *zatm_dev; |
1565 | |
1566 | zatm_dev = ZATM_DEV(dev); |
1567 | zwait; |
1568 | zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW | |
1569 | (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR); |
1570 | zwait; |
1571 | return zin(CER) & 0xff; |
1572 | } |
1573 | |
1574 | |
1575 | static const struct atmdev_ops ops = { |
1576 | .open = zatm_open, |
1577 | .close = zatm_close, |
1578 | .ioctl = zatm_ioctl, |
1579 | .getsockopt = zatm_getsockopt, |
1580 | .setsockopt = zatm_setsockopt, |
1581 | .send = zatm_send, |
1582 | .phy_put = zatm_phy_put, |
1583 | .phy_get = zatm_phy_get, |
1584 | .change_qos = zatm_change_qos, |
1585 | }; |
1586 | |
1587 | static int __devinit zatm_init_one(struct pci_dev *pci_dev, |
1588 | const struct pci_device_id *ent) |
1589 | { |
1590 | struct atm_dev *dev; |
1591 | struct zatm_dev *zatm_dev; |
1592 | int ret = -ENOMEM; |
1593 | |
1594 | zatm_dev = kmalloc(sizeof(*zatm_dev), GFP_KERNEL); |
1595 | if (!zatm_dev) { |
1596 | printk(KERN_EMERG "%s: memory shortage\n", DEV_LABEL); |
1597 | goto out; |
1598 | } |
1599 | |
1600 | dev = atm_dev_register(DEV_LABEL, &pci_dev->dev, &ops, -1, NULL); |
1601 | if (!dev) |
1602 | goto out_free; |
1603 | |
1604 | ret = pci_enable_device(pci_dev); |
1605 | if (ret < 0) |
1606 | goto out_deregister; |
1607 | |
1608 | ret = pci_request_regions(pci_dev, DEV_LABEL); |
1609 | if (ret < 0) |
1610 | goto out_disable; |
1611 | |
1612 | zatm_dev->pci_dev = pci_dev; |
1613 | dev->dev_data = zatm_dev; |
1614 | zatm_dev->copper = (int)ent->driver_data; |
1615 | if ((ret = zatm_init(dev)) || (ret = zatm_start(dev))) |
1616 | goto out_release; |
1617 | |
1618 | pci_set_drvdata(pci_dev, dev); |
1619 | zatm_dev->more = zatm_boards; |
1620 | zatm_boards = dev; |
1621 | ret = 0; |
1622 | out: |
1623 | return ret; |
1624 | |
1625 | out_release: |
1626 | pci_release_regions(pci_dev); |
1627 | out_disable: |
1628 | pci_disable_device(pci_dev); |
1629 | out_deregister: |
1630 | atm_dev_deregister(dev); |
1631 | out_free: |
1632 | kfree(zatm_dev); |
1633 | goto out; |
1634 | } |
1635 | |
1636 | |
1637 | MODULE_LICENSE("GPL"); |
1638 | |
1639 | static struct pci_device_id zatm_pci_tbl[] __devinitdata = { |
1640 | { PCI_VDEVICE(ZEITNET, PCI_DEVICE_ID_ZEITNET_1221), ZATM_COPPER }, |
1641 | { PCI_VDEVICE(ZEITNET, PCI_DEVICE_ID_ZEITNET_1225), 0 }, |
1642 | { 0, } |
1643 | }; |
1644 | MODULE_DEVICE_TABLE(pci, zatm_pci_tbl); |
1645 | |
1646 | static struct pci_driver zatm_driver = { |
1647 | .name = DEV_LABEL, |
1648 | .id_table = zatm_pci_tbl, |
1649 | .probe = zatm_init_one, |
1650 | }; |
1651 | |
1652 | static int __init zatm_init_module(void) |
1653 | { |
1654 | return pci_register_driver(&zatm_driver); |
1655 | } |
1656 | |
1657 | module_init(zatm_init_module); |
1658 | /* module_exit not defined so not unloadable */ |
1659 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9