4 * Device driver supporting CBR for IDT 77201/77211 "NICStAR" based cards.
6 * IMPORTANT: The included file nicstarmac.c was NOT WRITTEN BY ME.
7 * It was taken from the frle-0.22 device driver.
8 * As the file doesn't have a copyright notice, in the file
9 * nicstarmac.copyright I put the copyright notice from the
10 * frle-0.22 device driver.
11 * Some code is based on the nicstar driver by M. Welsh.
13 * Author: Rui Prior (rprior@inescn.pt)
14 * PowerPC support by Jay Talbott (jay_talbott@mcg.mot.com) April 1999
21 * IMPORTANT INFORMATION
23 * There are currently three types of spinlocks:
25 * 1 - Per card interrupt spinlock (to protect structures and such)
26 * 2 - Per SCQ scq spinlock
27 * 3 - Per card resource spinlock (to access registers, etc.)
29 * These must NEVER be grabbed in reverse order.
35 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/skbuff.h>
38 #include <linux/atmdev.h>
39 #include <linux/atm.h>
40 #include <linux/pci.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/types.h>
43 #include <linux/string.h>
44 #include <linux/delay.h>
45 #include <linux/init.h>
46 #include <linux/sched.h>
47 #include <linux/timer.h>
48 #include <linux/interrupt.h>
49 #include <linux/bitops.h>
50 #include <linux/slab.h>
51 #include <linux/idr.h>
53 #include <asm/uaccess.h>
54 #include <asm/atomic.h>
56 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
58 #endif /* CONFIG_ATM_NICSTAR_USE_SUNI */
59 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
61 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */
65 #include "nicstarmac.c"
67 /* Configurable parameters */
75 #undef NS_USE_DESTRUCTORS /* For now keep this undefined unless you know
76 you're going to use only raw ATM */
78 /* Do not touch these */
81 #define TXPRINTK(args...) printk(args)
83 #define TXPRINTK(args...)
87 #define RXPRINTK(args...) printk(args)
89 #define RXPRINTK(args...)
93 #define PRINTK(args...) printk(args)
95 #define PRINTK(args...)
96 #endif /* GENERAL_DEBUG */
99 #define XPRINTK(args...) printk(args)
101 #define XPRINTK(args...)
102 #endif /* EXTRA_DEBUG */
106 #define CMD_BUSY(card) (readl((card)->membase + STAT) & NS_STAT_CMDBZ)
108 #define NS_DELAY mdelay(1)
110 #define PTR_DIFF(a, b) ((u32)((unsigned long)(a) - (unsigned long)(b)))
113 #define ATM_SKB(s) (&(s)->atm)
116 #define scq_virt_to_bus(scq, p) \
117 (scq->dma + ((unsigned long)(p) - (unsigned long)(scq)->org))
119 /* Function declarations */
121 static u32
ns_read_sram(ns_dev
* card
, u32 sram_address
);
122 static void ns_write_sram(ns_dev
* card
, u32 sram_address
, u32
* value
,
124 static int __devinit
ns_init_card(int i
, struct pci_dev
*pcidev
);
125 static void __devinit
ns_init_card_error(ns_dev
* card
, int error
);
126 static scq_info
*get_scq(ns_dev
*card
, int size
, u32 scd
);
127 static void free_scq(ns_dev
*card
, scq_info
* scq
, struct atm_vcc
*vcc
);
128 static void push_rxbufs(ns_dev
*, struct sk_buff
*);
129 static irqreturn_t
ns_irq_handler(int irq
, void *dev_id
);
130 static int ns_open(struct atm_vcc
*vcc
);
131 static void ns_close(struct atm_vcc
*vcc
);
132 static void fill_tst(ns_dev
* card
, int n
, vc_map
* vc
);
133 static int ns_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
134 static int push_scqe(ns_dev
* card
, vc_map
* vc
, scq_info
* scq
, ns_scqe
* tbd
,
135 struct sk_buff
*skb
);
136 static void process_tsq(ns_dev
* card
);
137 static void drain_scq(ns_dev
* card
, scq_info
* scq
, int pos
);
138 static void process_rsq(ns_dev
* card
);
139 static void dequeue_rx(ns_dev
* card
, ns_rsqe
* rsqe
);
140 #ifdef NS_USE_DESTRUCTORS
141 static void ns_sb_destructor(struct sk_buff
*sb
);
142 static void ns_lb_destructor(struct sk_buff
*lb
);
143 static void ns_hb_destructor(struct sk_buff
*hb
);
144 #endif /* NS_USE_DESTRUCTORS */
145 static void recycle_rx_buf(ns_dev
* card
, struct sk_buff
*skb
);
146 static void recycle_iovec_rx_bufs(ns_dev
* card
, struct iovec
*iov
, int count
);
147 static void recycle_iov_buf(ns_dev
* card
, struct sk_buff
*iovb
);
148 static void dequeue_sm_buf(ns_dev
* card
, struct sk_buff
*sb
);
149 static void dequeue_lg_buf(ns_dev
* card
, struct sk_buff
*lb
);
150 static int ns_proc_read(struct atm_dev
*dev
, loff_t
* pos
, char *page
);
151 static int ns_ioctl(struct atm_dev
*dev
, unsigned int cmd
, void __user
* arg
);
153 static void which_list(ns_dev
* card
, struct sk_buff
*skb
);
155 static void ns_poll(unsigned long arg
);
156 static int ns_parse_mac(char *mac
, unsigned char *esi
);
157 static short ns_h2i(char c
);
158 static void ns_phy_put(struct atm_dev
*dev
, unsigned char value
,
160 static unsigned char ns_phy_get(struct atm_dev
*dev
, unsigned long addr
);
162 /* Global variables */
164 static struct ns_dev
*cards
[NS_MAX_CARDS
];
165 static unsigned num_cards
;
166 static struct atmdev_ops atm_ops
= {
171 .phy_put
= ns_phy_put
,
172 .phy_get
= ns_phy_get
,
173 .proc_read
= ns_proc_read
,
174 .owner
= THIS_MODULE
,
177 static struct timer_list ns_timer
;
178 static char *mac
[NS_MAX_CARDS
];
179 module_param_array(mac
, charp
, NULL
, 0);
180 MODULE_LICENSE("GPL");
184 static int __devinit
nicstar_init_one(struct pci_dev
*pcidev
,
185 const struct pci_device_id
*ent
)
187 static int index
= -1;
193 error
= ns_init_card(index
, pcidev
);
195 cards
[index
--] = NULL
; /* don't increment index */
204 static void __devexit
nicstar_remove_one(struct pci_dev
*pcidev
)
207 ns_dev
*card
= pci_get_drvdata(pcidev
);
209 struct sk_buff
*iovb
;
215 if (cards
[i
] == NULL
)
218 if (card
->atmdev
->phy
&& card
->atmdev
->phy
->stop
)
219 card
->atmdev
->phy
->stop(card
->atmdev
);
221 /* Stop everything */
222 writel(0x00000000, card
->membase
+ CFG
);
224 /* De-register device */
225 atm_dev_deregister(card
->atmdev
);
227 /* Disable PCI device */
228 pci_disable_device(pcidev
);
230 /* Free up resources */
232 PRINTK("nicstar%d: freeing %d huge buffers.\n", i
, card
->hbpool
.count
);
233 while ((hb
= skb_dequeue(&card
->hbpool
.queue
)) != NULL
) {
234 dev_kfree_skb_any(hb
);
237 PRINTK("nicstar%d: %d huge buffers freed.\n", i
, j
);
239 PRINTK("nicstar%d: freeing %d iovec buffers.\n", i
,
240 card
->iovpool
.count
);
241 while ((iovb
= skb_dequeue(&card
->iovpool
.queue
)) != NULL
) {
242 dev_kfree_skb_any(iovb
);
245 PRINTK("nicstar%d: %d iovec buffers freed.\n", i
, j
);
246 while ((lb
= skb_dequeue(&card
->lbpool
.queue
)) != NULL
)
247 dev_kfree_skb_any(lb
);
248 while ((sb
= skb_dequeue(&card
->sbpool
.queue
)) != NULL
)
249 dev_kfree_skb_any(sb
);
250 free_scq(card
, card
->scq0
, NULL
);
251 for (j
= 0; j
< NS_FRSCD_NUM
; j
++) {
252 if (card
->scd2vc
[j
] != NULL
)
253 free_scq(card
, card
->scd2vc
[j
]->scq
, card
->scd2vc
[j
]->tx_vcc
);
255 idr_remove_all(&card
->idr
);
256 idr_destroy(&card
->idr
);
257 pci_free_consistent(card
->pcidev
, NS_RSQSIZE
+ NS_RSQ_ALIGNMENT
,
258 card
->rsq
.org
, card
->rsq
.dma
);
259 pci_free_consistent(card
->pcidev
, NS_TSQSIZE
+ NS_TSQ_ALIGNMENT
,
260 card
->tsq
.org
, card
->tsq
.dma
);
261 free_irq(card
->pcidev
->irq
, card
);
262 iounmap(card
->membase
);
266 static struct pci_device_id nicstar_pci_tbl
[] __devinitdata
= {
267 {PCI_VENDOR_ID_IDT
, PCI_DEVICE_ID_IDT_IDT77201
,
268 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
269 {0,} /* terminate list */
272 MODULE_DEVICE_TABLE(pci
, nicstar_pci_tbl
);
274 static struct pci_driver nicstar_driver
= {
276 .id_table
= nicstar_pci_tbl
,
277 .probe
= nicstar_init_one
,
278 .remove
= __devexit_p(nicstar_remove_one
),
281 static int __init
nicstar_init(void)
283 unsigned error
= 0; /* Initialized to remove compile warning */
285 XPRINTK("nicstar: nicstar_init() called.\n");
287 error
= pci_register_driver(&nicstar_driver
);
289 TXPRINTK("nicstar: TX debug enabled.\n");
290 RXPRINTK("nicstar: RX debug enabled.\n");
291 PRINTK("nicstar: General debug enabled.\n");
293 printk("nicstar: using PHY loopback.\n");
294 #endif /* PHY_LOOPBACK */
295 XPRINTK("nicstar: nicstar_init() returned.\n");
298 init_timer(&ns_timer
);
299 ns_timer
.expires
= jiffies
+ NS_POLL_PERIOD
;
301 ns_timer
.function
= ns_poll
;
302 add_timer(&ns_timer
);
308 static void __exit
nicstar_cleanup(void)
310 XPRINTK("nicstar: nicstar_cleanup() called.\n");
312 del_timer(&ns_timer
);
314 pci_unregister_driver(&nicstar_driver
);
316 XPRINTK("nicstar: nicstar_cleanup() returned.\n");
319 static u32
ns_read_sram(ns_dev
* card
, u32 sram_address
)
324 sram_address
&= 0x0007FFFC; /* address must be dword aligned */
325 sram_address
|= 0x50000000; /* SRAM read command */
326 spin_lock_irqsave(&card
->res_lock
, flags
);
327 while (CMD_BUSY(card
)) ;
328 writel(sram_address
, card
->membase
+ CMD
);
329 while (CMD_BUSY(card
)) ;
330 data
= readl(card
->membase
+ DR0
);
331 spin_unlock_irqrestore(&card
->res_lock
, flags
);
335 static void ns_write_sram(ns_dev
* card
, u32 sram_address
, u32
* value
,
340 count
--; /* count range now is 0..3 instead of 1..4 */
342 c
<<= 2; /* to use increments of 4 */
343 spin_lock_irqsave(&card
->res_lock
, flags
);
344 while (CMD_BUSY(card
)) ;
345 for (i
= 0; i
<= c
; i
+= 4)
346 writel(*(value
++), card
->membase
+ i
);
347 /* Note: DR# registers are the first 4 dwords in nicstar's memspace,
348 so card->membase + DR0 == card->membase */
350 sram_address
&= 0x0007FFFC;
351 sram_address
|= (0x40000000 | count
);
352 writel(sram_address
, card
->membase
+ CMD
);
353 spin_unlock_irqrestore(&card
->res_lock
, flags
);
356 static int __devinit
ns_init_card(int i
, struct pci_dev
*pcidev
)
359 struct ns_dev
*card
= NULL
;
360 unsigned char pci_latency
;
366 unsigned long membase
;
370 if (pci_enable_device(pcidev
)) {
371 printk("nicstar%d: can't enable PCI device\n", i
);
373 ns_init_card_error(card
, error
);
376 if ((pci_set_dma_mask(pcidev
, DMA_BIT_MASK(32)) != 0) ||
377 (pci_set_consistent_dma_mask(pcidev
, DMA_BIT_MASK(32)) != 0)) {
379 "nicstar%d: No suitable DMA available.\n", i
);
381 ns_init_card_error(card
, error
);
385 if ((card
= kmalloc(sizeof(ns_dev
), GFP_KERNEL
)) == NULL
) {
387 ("nicstar%d: can't allocate memory for device structure.\n",
390 ns_init_card_error(card
, error
);
394 spin_lock_init(&card
->int_lock
);
395 spin_lock_init(&card
->res_lock
);
397 pci_set_drvdata(pcidev
, card
);
401 card
->pcidev
= pcidev
;
402 membase
= pci_resource_start(pcidev
, 1);
403 card
->membase
= ioremap(membase
, NS_IOREMAP_SIZE
);
404 if (!card
->membase
) {
405 printk("nicstar%d: can't ioremap() membase.\n", i
);
407 ns_init_card_error(card
, error
);
410 PRINTK("nicstar%d: membase at 0x%p.\n", i
, card
->membase
);
412 pci_set_master(pcidev
);
414 if (pci_read_config_byte(pcidev
, PCI_LATENCY_TIMER
, &pci_latency
) != 0) {
415 printk("nicstar%d: can't read PCI latency timer.\n", i
);
417 ns_init_card_error(card
, error
);
420 #ifdef NS_PCI_LATENCY
421 if (pci_latency
< NS_PCI_LATENCY
) {
422 PRINTK("nicstar%d: setting PCI latency timer to %d.\n", i
,
424 for (j
= 1; j
< 4; j
++) {
425 if (pci_write_config_byte
426 (pcidev
, PCI_LATENCY_TIMER
, NS_PCI_LATENCY
) != 0)
431 ("nicstar%d: can't set PCI latency timer to %d.\n",
434 ns_init_card_error(card
, error
);
438 #endif /* NS_PCI_LATENCY */
440 /* Clear timer overflow */
441 data
= readl(card
->membase
+ STAT
);
442 if (data
& NS_STAT_TMROF
)
443 writel(NS_STAT_TMROF
, card
->membase
+ STAT
);
446 writel(NS_CFG_SWRST
, card
->membase
+ CFG
);
448 writel(0x00000000, card
->membase
+ CFG
);
451 writel(0x00000008, card
->membase
+ GP
);
453 writel(0x00000001, card
->membase
+ GP
);
455 while (CMD_BUSY(card
)) ;
456 writel(NS_CMD_WRITE_UTILITY
| 0x00000100, card
->membase
+ CMD
); /* Sync UTOPIA with SAR clock */
459 /* Detect PHY type */
460 while (CMD_BUSY(card
)) ;
461 writel(NS_CMD_READ_UTILITY
| 0x00000200, card
->membase
+ CMD
);
462 while (CMD_BUSY(card
)) ;
463 data
= readl(card
->membase
+ DR0
);
466 printk("nicstar%d: PHY seems to be 25 Mbps.\n", i
);
467 card
->max_pcr
= ATM_25_PCR
;
468 while (CMD_BUSY(card
)) ;
469 writel(0x00000008, card
->membase
+ DR0
);
470 writel(NS_CMD_WRITE_UTILITY
| 0x00000200, card
->membase
+ CMD
);
471 /* Clear an eventual pending interrupt */
472 writel(NS_STAT_SFBQF
, card
->membase
+ STAT
);
474 while (CMD_BUSY(card
)) ;
475 writel(0x00000022, card
->membase
+ DR0
);
476 writel(NS_CMD_WRITE_UTILITY
| 0x00000202, card
->membase
+ CMD
);
477 #endif /* PHY_LOOPBACK */
481 printk("nicstar%d: PHY seems to be 155 Mbps.\n", i
);
482 card
->max_pcr
= ATM_OC3_PCR
;
484 while (CMD_BUSY(card
)) ;
485 writel(0x00000002, card
->membase
+ DR0
);
486 writel(NS_CMD_WRITE_UTILITY
| 0x00000205, card
->membase
+ CMD
);
487 #endif /* PHY_LOOPBACK */
490 printk("nicstar%d: unknown PHY type (0x%08X).\n", i
, data
);
492 ns_init_card_error(card
, error
);
495 writel(0x00000000, card
->membase
+ GP
);
497 /* Determine SRAM size */
499 ns_write_sram(card
, 0x1C003, &data
, 1);
501 ns_write_sram(card
, 0x14003, &data
, 1);
502 if (ns_read_sram(card
, 0x14003) == 0x89ABCDEF &&
503 ns_read_sram(card
, 0x1C003) == 0x76543210)
504 card
->sram_size
= 128;
506 card
->sram_size
= 32;
507 PRINTK("nicstar%d: %dK x 32bit SRAM size.\n", i
, card
->sram_size
);
509 card
->rct_size
= NS_MAX_RCTSIZE
;
511 #if (NS_MAX_RCTSIZE == 4096)
512 if (card
->sram_size
== 128)
514 ("nicstar%d: limiting maximum VCI. See NS_MAX_RCTSIZE in nicstar.h\n",
516 #elif (NS_MAX_RCTSIZE == 16384)
517 if (card
->sram_size
== 32) {
519 ("nicstar%d: wasting memory. See NS_MAX_RCTSIZE in nicstar.h\n",
521 card
->rct_size
= 4096;
524 #error NS_MAX_RCTSIZE must be either 4096 or 16384 in nicstar.c
527 card
->vpibits
= NS_VPIBITS
;
528 if (card
->rct_size
== 4096)
529 card
->vcibits
= 12 - NS_VPIBITS
;
530 else /* card->rct_size == 16384 */
531 card
->vcibits
= 14 - NS_VPIBITS
;
533 /* Initialize the nicstar eeprom/eprom stuff, for the MAC addr */
535 nicstar_init_eprom(card
->membase
);
537 /* Set the VPI/VCI MSb mask to zero so we can receive OAM cells */
538 writel(0x00000000, card
->membase
+ VPM
);
541 card
->tsq
.org
= pci_alloc_consistent(card
->pcidev
,
542 NS_TSQSIZE
+ NS_TSQ_ALIGNMENT
,
544 if (card
->tsq
.org
== NULL
) {
545 printk("nicstar%d: can't allocate TSQ.\n", i
);
547 ns_init_card_error(card
, error
);
550 card
->tsq
.base
= PTR_ALIGN(card
->tsq
.org
, NS_TSQ_ALIGNMENT
);
551 card
->tsq
.next
= card
->tsq
.base
;
552 card
->tsq
.last
= card
->tsq
.base
+ (NS_TSQ_NUM_ENTRIES
- 1);
553 for (j
= 0; j
< NS_TSQ_NUM_ENTRIES
; j
++)
554 ns_tsi_init(card
->tsq
.base
+ j
);
555 writel(0x00000000, card
->membase
+ TSQH
);
556 writel(ALIGN(card
->tsq
.dma
, NS_TSQ_ALIGNMENT
), card
->membase
+ TSQB
);
557 PRINTK("nicstar%d: TSQ base at 0x%p.\n", i
, card
->tsq
.base
);
560 card
->rsq
.org
= pci_alloc_consistent(card
->pcidev
,
561 NS_RSQSIZE
+ NS_RSQ_ALIGNMENT
,
563 if (card
->rsq
.org
== NULL
) {
564 printk("nicstar%d: can't allocate RSQ.\n", i
);
566 ns_init_card_error(card
, error
);
569 card
->rsq
.base
= PTR_ALIGN(card
->rsq
.org
, NS_RSQ_ALIGNMENT
);
570 card
->rsq
.next
= card
->rsq
.base
;
571 card
->rsq
.last
= card
->rsq
.base
+ (NS_RSQ_NUM_ENTRIES
- 1);
572 for (j
= 0; j
< NS_RSQ_NUM_ENTRIES
; j
++)
573 ns_rsqe_init(card
->rsq
.base
+ j
);
574 writel(0x00000000, card
->membase
+ RSQH
);
575 writel(ALIGN(card
->rsq
.dma
, NS_RSQ_ALIGNMENT
), card
->membase
+ RSQB
);
576 PRINTK("nicstar%d: RSQ base at 0x%p.\n", i
, card
->rsq
.base
);
578 /* Initialize SCQ0, the only VBR SCQ used */
581 card
->scq0
= get_scq(card
, VBR_SCQSIZE
, NS_VRSCD0
);
582 if (card
->scq0
== NULL
) {
583 printk("nicstar%d: can't get SCQ0.\n", i
);
585 ns_init_card_error(card
, error
);
588 u32d
[0] = scq_virt_to_bus(card
->scq0
, card
->scq0
->base
);
589 u32d
[1] = (u32
) 0x00000000;
590 u32d
[2] = (u32
) 0xffffffff;
591 u32d
[3] = (u32
) 0x00000000;
592 ns_write_sram(card
, NS_VRSCD0
, u32d
, 4);
593 ns_write_sram(card
, NS_VRSCD1
, u32d
, 4); /* These last two won't be used */
594 ns_write_sram(card
, NS_VRSCD2
, u32d
, 4); /* but are initialized, just in case... */
595 card
->scq0
->scd
= NS_VRSCD0
;
596 PRINTK("nicstar%d: VBR-SCQ0 base at 0x%p.\n", i
, card
->scq0
->base
);
598 /* Initialize TSTs */
599 card
->tst_addr
= NS_TST0
;
600 card
->tst_free_entries
= NS_TST_NUM_ENTRIES
;
601 data
= NS_TST_OPCODE_VARIABLE
;
602 for (j
= 0; j
< NS_TST_NUM_ENTRIES
; j
++)
603 ns_write_sram(card
, NS_TST0
+ j
, &data
, 1);
604 data
= ns_tste_make(NS_TST_OPCODE_END
, NS_TST0
);
605 ns_write_sram(card
, NS_TST0
+ NS_TST_NUM_ENTRIES
, &data
, 1);
606 for (j
= 0; j
< NS_TST_NUM_ENTRIES
; j
++)
607 ns_write_sram(card
, NS_TST1
+ j
, &data
, 1);
608 data
= ns_tste_make(NS_TST_OPCODE_END
, NS_TST1
);
609 ns_write_sram(card
, NS_TST1
+ NS_TST_NUM_ENTRIES
, &data
, 1);
610 for (j
= 0; j
< NS_TST_NUM_ENTRIES
; j
++)
611 card
->tste2vc
[j
] = NULL
;
612 writel(NS_TST0
<< 2, card
->membase
+ TSTB
);
614 /* Initialize RCT. AAL type is set on opening the VC. */
616 u32d
[0] = NS_RCTE_RAWCELLINTEN
;
618 u32d
[0] = 0x00000000;
619 #endif /* RCQ_SUPPORT */
620 u32d
[1] = 0x00000000;
621 u32d
[2] = 0x00000000;
622 u32d
[3] = 0xFFFFFFFF;
623 for (j
= 0; j
< card
->rct_size
; j
++)
624 ns_write_sram(card
, j
* 4, u32d
, 4);
626 memset(card
->vcmap
, 0, NS_MAX_RCTSIZE
* sizeof(vc_map
));
628 for (j
= 0; j
< NS_FRSCD_NUM
; j
++)
629 card
->scd2vc
[j
] = NULL
;
631 /* Initialize buffer levels */
632 card
->sbnr
.min
= MIN_SB
;
633 card
->sbnr
.init
= NUM_SB
;
634 card
->sbnr
.max
= MAX_SB
;
635 card
->lbnr
.min
= MIN_LB
;
636 card
->lbnr
.init
= NUM_LB
;
637 card
->lbnr
.max
= MAX_LB
;
638 card
->iovnr
.min
= MIN_IOVB
;
639 card
->iovnr
.init
= NUM_IOVB
;
640 card
->iovnr
.max
= MAX_IOVB
;
641 card
->hbnr
.min
= MIN_HB
;
642 card
->hbnr
.init
= NUM_HB
;
643 card
->hbnr
.max
= MAX_HB
;
645 card
->sm_handle
= 0x00000000;
646 card
->sm_addr
= 0x00000000;
647 card
->lg_handle
= 0x00000000;
648 card
->lg_addr
= 0x00000000;
650 card
->efbie
= 1; /* To prevent push_rxbufs from enabling the interrupt */
652 idr_init(&card
->idr
);
654 /* Pre-allocate some huge buffers */
655 skb_queue_head_init(&card
->hbpool
.queue
);
656 card
->hbpool
.count
= 0;
657 for (j
= 0; j
< NUM_HB
; j
++) {
659 hb
= __dev_alloc_skb(NS_HBUFSIZE
, GFP_KERNEL
);
662 ("nicstar%d: can't allocate %dth of %d huge buffers.\n",
665 ns_init_card_error(card
, error
);
668 NS_PRV_BUFTYPE(hb
) = BUF_NONE
;
669 skb_queue_tail(&card
->hbpool
.queue
, hb
);
670 card
->hbpool
.count
++;
673 /* Allocate large buffers */
674 skb_queue_head_init(&card
->lbpool
.queue
);
675 card
->lbpool
.count
= 0; /* Not used */
676 for (j
= 0; j
< NUM_LB
; j
++) {
678 lb
= __dev_alloc_skb(NS_LGSKBSIZE
, GFP_KERNEL
);
681 ("nicstar%d: can't allocate %dth of %d large buffers.\n",
684 ns_init_card_error(card
, error
);
687 NS_PRV_BUFTYPE(lb
) = BUF_LG
;
688 skb_queue_tail(&card
->lbpool
.queue
, lb
);
689 skb_reserve(lb
, NS_SMBUFSIZE
);
690 push_rxbufs(card
, lb
);
691 /* Due to the implementation of push_rxbufs() this is 1, not 0 */
694 card
->rawcell
= (struct ns_rcqe
*) lb
->data
;
695 card
->rawch
= NS_PRV_DMA(lb
);
698 /* Test for strange behaviour which leads to crashes */
700 ns_stat_lfbqc_get(readl(card
->membase
+ STAT
))) < card
->lbnr
.min
) {
702 ("nicstar%d: Strange... Just allocated %d large buffers and lfbqc = %d.\n",
705 ns_init_card_error(card
, error
);
709 /* Allocate small buffers */
710 skb_queue_head_init(&card
->sbpool
.queue
);
711 card
->sbpool
.count
= 0; /* Not used */
712 for (j
= 0; j
< NUM_SB
; j
++) {
714 sb
= __dev_alloc_skb(NS_SMSKBSIZE
, GFP_KERNEL
);
717 ("nicstar%d: can't allocate %dth of %d small buffers.\n",
720 ns_init_card_error(card
, error
);
723 NS_PRV_BUFTYPE(sb
) = BUF_SM
;
724 skb_queue_tail(&card
->sbpool
.queue
, sb
);
725 skb_reserve(sb
, NS_AAL0_HEADER
);
726 push_rxbufs(card
, sb
);
728 /* Test for strange behaviour which leads to crashes */
730 ns_stat_sfbqc_get(readl(card
->membase
+ STAT
))) < card
->sbnr
.min
) {
732 ("nicstar%d: Strange... Just allocated %d small buffers and sfbqc = %d.\n",
735 ns_init_card_error(card
, error
);
739 /* Allocate iovec buffers */
740 skb_queue_head_init(&card
->iovpool
.queue
);
741 card
->iovpool
.count
= 0;
742 for (j
= 0; j
< NUM_IOVB
; j
++) {
743 struct sk_buff
*iovb
;
744 iovb
= alloc_skb(NS_IOVBUFSIZE
, GFP_KERNEL
);
747 ("nicstar%d: can't allocate %dth of %d iovec buffers.\n",
750 ns_init_card_error(card
, error
);
753 NS_PRV_BUFTYPE(iovb
) = BUF_NONE
;
754 skb_queue_tail(&card
->iovpool
.queue
, iovb
);
755 card
->iovpool
.count
++;
758 /* Configure NICStAR */
759 if (card
->rct_size
== 4096)
760 ns_cfg_rctsize
= NS_CFG_RCTSIZE_4096_ENTRIES
;
761 else /* (card->rct_size == 16384) */
762 ns_cfg_rctsize
= NS_CFG_RCTSIZE_16384_ENTRIES
;
768 (pcidev
->irq
, &ns_irq_handler
, IRQF_SHARED
, "nicstar", card
) != 0) {
769 printk("nicstar%d: can't allocate IRQ %d.\n", i
, pcidev
->irq
);
771 ns_init_card_error(card
, error
);
775 /* Register device */
776 card
->atmdev
= atm_dev_register("nicstar", &atm_ops
, -1, NULL
);
777 if (card
->atmdev
== NULL
) {
778 printk("nicstar%d: can't register device.\n", i
);
780 ns_init_card_error(card
, error
);
784 if (ns_parse_mac(mac
[i
], card
->atmdev
->esi
)) {
785 nicstar_read_eprom(card
->membase
, NICSTAR_EPROM_MAC_ADDR_OFFSET
,
786 card
->atmdev
->esi
, 6);
787 if (memcmp(card
->atmdev
->esi
, "\x00\x00\x00\x00\x00\x00", 6) ==
789 nicstar_read_eprom(card
->membase
,
790 NICSTAR_EPROM_MAC_ADDR_OFFSET_ALT
,
791 card
->atmdev
->esi
, 6);
795 printk("nicstar%d: MAC address %pM\n", i
, card
->atmdev
->esi
);
797 card
->atmdev
->dev_data
= card
;
798 card
->atmdev
->ci_range
.vpi_bits
= card
->vpibits
;
799 card
->atmdev
->ci_range
.vci_bits
= card
->vcibits
;
800 card
->atmdev
->link_rate
= card
->max_pcr
;
801 card
->atmdev
->phy
= NULL
;
803 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
804 if (card
->max_pcr
== ATM_OC3_PCR
)
805 suni_init(card
->atmdev
);
806 #endif /* CONFIG_ATM_NICSTAR_USE_SUNI */
808 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
809 if (card
->max_pcr
== ATM_25_PCR
)
810 idt77105_init(card
->atmdev
);
811 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */
813 if (card
->atmdev
->phy
&& card
->atmdev
->phy
->start
)
814 card
->atmdev
->phy
->start(card
->atmdev
);
816 writel(NS_CFG_RXPATH
| NS_CFG_SMBUFSIZE
| NS_CFG_LGBUFSIZE
| NS_CFG_EFBIE
| NS_CFG_RSQSIZE
| NS_CFG_VPIBITS
| ns_cfg_rctsize
| NS_CFG_RXINT_NODELAY
| NS_CFG_RAWIE
| /* Only enabled if RCQ_SUPPORT */
817 NS_CFG_RSQAFIE
| NS_CFG_TXEN
| NS_CFG_TXIE
| NS_CFG_TSQFIE_OPT
| /* Only enabled if ENABLE_TSQFIE */
818 NS_CFG_PHYIE
, card
->membase
+ CFG
);
825 static void __devinit
ns_init_card_error(ns_dev
* card
, int error
)
828 writel(0x00000000, card
->membase
+ CFG
);
831 struct sk_buff
*iovb
;
832 while ((iovb
= skb_dequeue(&card
->iovpool
.queue
)) != NULL
)
833 dev_kfree_skb_any(iovb
);
837 while ((sb
= skb_dequeue(&card
->sbpool
.queue
)) != NULL
)
838 dev_kfree_skb_any(sb
);
839 free_scq(card
, card
->scq0
, NULL
);
843 while ((lb
= skb_dequeue(&card
->lbpool
.queue
)) != NULL
)
844 dev_kfree_skb_any(lb
);
848 while ((hb
= skb_dequeue(&card
->hbpool
.queue
)) != NULL
)
849 dev_kfree_skb_any(hb
);
852 kfree(card
->rsq
.org
);
855 kfree(card
->tsq
.org
);
858 free_irq(card
->pcidev
->irq
, card
);
861 iounmap(card
->membase
);
864 pci_disable_device(card
->pcidev
);
869 static scq_info
*get_scq(ns_dev
*card
, int size
, u32 scd
)
874 if (size
!= VBR_SCQSIZE
&& size
!= CBR_SCQSIZE
)
877 scq
= kmalloc(sizeof(scq_info
), GFP_KERNEL
);
880 scq
->org
= pci_alloc_consistent(card
->pcidev
, 2 * size
, &scq
->dma
);
885 scq
->skb
= kmalloc(sizeof(struct sk_buff
*) *
886 (size
/ NS_SCQE_SIZE
), GFP_KERNEL
);
892 scq
->num_entries
= size
/ NS_SCQE_SIZE
;
893 scq
->base
= PTR_ALIGN(scq
->org
, size
);
894 scq
->next
= scq
->base
;
895 scq
->last
= scq
->base
+ (scq
->num_entries
- 1);
896 scq
->tail
= scq
->last
;
898 scq
->num_entries
= size
/ NS_SCQE_SIZE
;
900 init_waitqueue_head(&scq
->scqfull_waitq
);
902 spin_lock_init(&scq
->lock
);
904 for (i
= 0; i
< scq
->num_entries
; i
++)
910 /* For variable rate SCQ vcc must be NULL */
911 static void free_scq(ns_dev
*card
, scq_info
*scq
, struct atm_vcc
*vcc
)
915 if (scq
->num_entries
== VBR_SCQ_NUM_ENTRIES
)
916 for (i
= 0; i
< scq
->num_entries
; i
++) {
917 if (scq
->skb
[i
] != NULL
) {
918 vcc
= ATM_SKB(scq
->skb
[i
])->vcc
;
919 if (vcc
->pop
!= NULL
)
920 vcc
->pop(vcc
, scq
->skb
[i
]);
922 dev_kfree_skb_any(scq
->skb
[i
]);
924 } else { /* vcc must be != NULL */
928 ("nicstar: free_scq() called with vcc == NULL for fixed rate scq.");
929 for (i
= 0; i
< scq
->num_entries
; i
++)
930 dev_kfree_skb_any(scq
->skb
[i
]);
932 for (i
= 0; i
< scq
->num_entries
; i
++) {
933 if (scq
->skb
[i
] != NULL
) {
934 if (vcc
->pop
!= NULL
)
935 vcc
->pop(vcc
, scq
->skb
[i
]);
937 dev_kfree_skb_any(scq
->skb
[i
]);
942 pci_free_consistent(card
->pcidev
,
943 2 * (scq
->num_entries
== VBR_SCQ_NUM_ENTRIES
?
944 VBR_SCQSIZE
: CBR_SCQSIZE
),
949 /* The handles passed must be pointers to the sk_buff containing the small
950 or large buffer(s) cast to u32. */
951 static void push_rxbufs(ns_dev
* card
, struct sk_buff
*skb
)
953 struct sk_buff
*handle1
, *handle2
;
954 u32 id1
= 0, id2
= 0;
964 addr1
= pci_map_single(card
->pcidev
,
966 (NS_PRV_BUFTYPE(skb
) == BUF_SM
967 ? NS_SMSKBSIZE
: NS_LGSKBSIZE
),
969 NS_PRV_DMA(skb
) = addr1
; /* save so we can unmap later */
973 printk("nicstar%d: push_rxbufs called with addr1 = 0.\n",
975 #endif /* GENERAL_DEBUG */
977 stat
= readl(card
->membase
+ STAT
);
978 card
->sbfqc
= ns_stat_sfbqc_get(stat
);
979 card
->lbfqc
= ns_stat_lfbqc_get(stat
);
980 if (NS_PRV_BUFTYPE(skb
) == BUF_SM
) {
983 addr2
= card
->sm_addr
;
984 handle2
= card
->sm_handle
;
985 card
->sm_addr
= 0x00000000;
986 card
->sm_handle
= 0x00000000;
987 } else { /* (!sm_addr) */
989 card
->sm_addr
= addr1
;
990 card
->sm_handle
= handle1
;
993 } else { /* buf_type == BUF_LG */
997 addr2
= card
->lg_addr
;
998 handle2
= card
->lg_handle
;
999 card
->lg_addr
= 0x00000000;
1000 card
->lg_handle
= 0x00000000;
1001 } else { /* (!lg_addr) */
1003 card
->lg_addr
= addr1
;
1004 card
->lg_handle
= handle1
;
1010 if (NS_PRV_BUFTYPE(skb
) == BUF_SM
) {
1011 if (card
->sbfqc
>= card
->sbnr
.max
) {
1012 skb_unlink(handle1
, &card
->sbpool
.queue
);
1013 dev_kfree_skb_any(handle1
);
1014 skb_unlink(handle2
, &card
->sbpool
.queue
);
1015 dev_kfree_skb_any(handle2
);
1019 } else { /* (buf_type == BUF_LG) */
1021 if (card
->lbfqc
>= card
->lbnr
.max
) {
1022 skb_unlink(handle1
, &card
->lbpool
.queue
);
1023 dev_kfree_skb_any(handle1
);
1024 skb_unlink(handle2
, &card
->lbpool
.queue
);
1025 dev_kfree_skb_any(handle2
);
1032 if (!idr_pre_get(&card
->idr
, GFP_ATOMIC
)) {
1034 "nicstar%d: no free memory for idr\n",
1040 err
= idr_get_new_above(&card
->idr
, handle1
, 0, &id1
);
1042 if (!id2
&& err
== 0)
1043 err
= idr_get_new_above(&card
->idr
, handle2
, 0, &id2
);
1045 } while (err
== -EAGAIN
);
1050 spin_lock_irqsave(&card
->res_lock
, flags
);
1051 while (CMD_BUSY(card
)) ;
1052 writel(addr2
, card
->membase
+ DR3
);
1053 writel(id2
, card
->membase
+ DR2
);
1054 writel(addr1
, card
->membase
+ DR1
);
1055 writel(id1
, card
->membase
+ DR0
);
1056 writel(NS_CMD_WRITE_FREEBUFQ
| NS_PRV_BUFTYPE(skb
),
1057 card
->membase
+ CMD
);
1058 spin_unlock_irqrestore(&card
->res_lock
, flags
);
1060 XPRINTK("nicstar%d: Pushing %s buffers at 0x%x and 0x%x.\n",
1062 (NS_PRV_BUFTYPE(skb
) == BUF_SM
? "small" : "large"),
1066 if (!card
->efbie
&& card
->sbfqc
>= card
->sbnr
.min
&&
1067 card
->lbfqc
>= card
->lbnr
.min
) {
1069 writel((readl(card
->membase
+ CFG
) | NS_CFG_EFBIE
),
1070 card
->membase
+ CFG
);
1077 static irqreturn_t
ns_irq_handler(int irq
, void *dev_id
)
1081 struct atm_dev
*dev
;
1082 unsigned long flags
;
1084 card
= (ns_dev
*) dev_id
;
1088 PRINTK("nicstar%d: NICStAR generated an interrupt\n", card
->index
);
1090 spin_lock_irqsave(&card
->int_lock
, flags
);
1092 stat_r
= readl(card
->membase
+ STAT
);
1094 /* Transmit Status Indicator has been written to T. S. Queue */
1095 if (stat_r
& NS_STAT_TSIF
) {
1096 TXPRINTK("nicstar%d: TSI interrupt\n", card
->index
);
1098 writel(NS_STAT_TSIF
, card
->membase
+ STAT
);
1101 /* Incomplete CS-PDU has been transmitted */
1102 if (stat_r
& NS_STAT_TXICP
) {
1103 writel(NS_STAT_TXICP
, card
->membase
+ STAT
);
1104 TXPRINTK("nicstar%d: Incomplete CS-PDU transmitted.\n",
1108 /* Transmit Status Queue 7/8 full */
1109 if (stat_r
& NS_STAT_TSQF
) {
1110 writel(NS_STAT_TSQF
, card
->membase
+ STAT
);
1111 PRINTK("nicstar%d: TSQ full.\n", card
->index
);
1115 /* Timer overflow */
1116 if (stat_r
& NS_STAT_TMROF
) {
1117 writel(NS_STAT_TMROF
, card
->membase
+ STAT
);
1118 PRINTK("nicstar%d: Timer overflow.\n", card
->index
);
1121 /* PHY device interrupt signal active */
1122 if (stat_r
& NS_STAT_PHYI
) {
1123 writel(NS_STAT_PHYI
, card
->membase
+ STAT
);
1124 PRINTK("nicstar%d: PHY interrupt.\n", card
->index
);
1125 if (dev
->phy
&& dev
->phy
->interrupt
) {
1126 dev
->phy
->interrupt(dev
);
1130 /* Small Buffer Queue is full */
1131 if (stat_r
& NS_STAT_SFBQF
) {
1132 writel(NS_STAT_SFBQF
, card
->membase
+ STAT
);
1133 printk("nicstar%d: Small free buffer queue is full.\n",
1137 /* Large Buffer Queue is full */
1138 if (stat_r
& NS_STAT_LFBQF
) {
1139 writel(NS_STAT_LFBQF
, card
->membase
+ STAT
);
1140 printk("nicstar%d: Large free buffer queue is full.\n",
1144 /* Receive Status Queue is full */
1145 if (stat_r
& NS_STAT_RSQF
) {
1146 writel(NS_STAT_RSQF
, card
->membase
+ STAT
);
1147 printk("nicstar%d: RSQ full.\n", card
->index
);
1151 /* Complete CS-PDU received */
1152 if (stat_r
& NS_STAT_EOPDU
) {
1153 RXPRINTK("nicstar%d: End of CS-PDU received.\n", card
->index
);
1155 writel(NS_STAT_EOPDU
, card
->membase
+ STAT
);
1158 /* Raw cell received */
1159 if (stat_r
& NS_STAT_RAWCF
) {
1160 writel(NS_STAT_RAWCF
, card
->membase
+ STAT
);
1162 printk("nicstar%d: Raw cell received and no support yet...\n",
1164 #endif /* RCQ_SUPPORT */
1165 /* NOTE: the following procedure may keep a raw cell pending until the
1166 next interrupt. As this preliminary support is only meant to
1167 avoid buffer leakage, this is not an issue. */
1168 while (readl(card
->membase
+ RAWCT
) != card
->rawch
) {
1170 if (ns_rcqe_islast(card
->rawcell
)) {
1171 struct sk_buff
*oldbuf
;
1173 oldbuf
= card
->rcbuf
;
1174 card
->rcbuf
= idr_find(&card
->idr
,
1175 ns_rcqe_nextbufhandle(card
->rawcell
));
1176 card
->rawch
= NS_PRV_DMA(card
->rcbuf
);
1177 card
->rawcell
= (struct ns_rcqe
*)
1179 recycle_rx_buf(card
, oldbuf
);
1181 card
->rawch
+= NS_RCQE_SIZE
;
1187 /* Small buffer queue is empty */
1188 if (stat_r
& NS_STAT_SFBQE
) {
1192 writel(NS_STAT_SFBQE
, card
->membase
+ STAT
);
1193 printk("nicstar%d: Small free buffer queue empty.\n",
1195 for (i
= 0; i
< card
->sbnr
.min
; i
++) {
1196 sb
= dev_alloc_skb(NS_SMSKBSIZE
);
1198 writel(readl(card
->membase
+ CFG
) &
1199 ~NS_CFG_EFBIE
, card
->membase
+ CFG
);
1203 NS_PRV_BUFTYPE(sb
) = BUF_SM
;
1204 skb_queue_tail(&card
->sbpool
.queue
, sb
);
1205 skb_reserve(sb
, NS_AAL0_HEADER
);
1206 push_rxbufs(card
, sb
);
1212 /* Large buffer queue empty */
1213 if (stat_r
& NS_STAT_LFBQE
) {
1217 writel(NS_STAT_LFBQE
, card
->membase
+ STAT
);
1218 printk("nicstar%d: Large free buffer queue empty.\n",
1220 for (i
= 0; i
< card
->lbnr
.min
; i
++) {
1221 lb
= dev_alloc_skb(NS_LGSKBSIZE
);
1223 writel(readl(card
->membase
+ CFG
) &
1224 ~NS_CFG_EFBIE
, card
->membase
+ CFG
);
1228 NS_PRV_BUFTYPE(lb
) = BUF_LG
;
1229 skb_queue_tail(&card
->lbpool
.queue
, lb
);
1230 skb_reserve(lb
, NS_SMBUFSIZE
);
1231 push_rxbufs(card
, lb
);
1237 /* Receive Status Queue is 7/8 full */
1238 if (stat_r
& NS_STAT_RSQAF
) {
1239 writel(NS_STAT_RSQAF
, card
->membase
+ STAT
);
1240 RXPRINTK("nicstar%d: RSQ almost full.\n", card
->index
);
1244 spin_unlock_irqrestore(&card
->int_lock
, flags
);
1245 PRINTK("nicstar%d: end of interrupt service\n", card
->index
);
1249 static int ns_open(struct atm_vcc
*vcc
)
1253 unsigned long tmpl
, modl
;
1254 int tcr
, tcra
; /* target cell rate, and absolute value */
1255 int n
= 0; /* Number of entries in the TST. Initialized to remove
1256 the compiler warning. */
1258 int frscdi
= 0; /* Index of the SCD. Initialized to remove the compiler
1259 warning. How I wish compilers were clever enough to
1260 tell which variables can truly be used
1262 int inuse
; /* tx or rx vc already in use by another vcc */
1263 short vpi
= vcc
->vpi
;
1266 card
= (ns_dev
*) vcc
->dev
->dev_data
;
1267 PRINTK("nicstar%d: opening vpi.vci %d.%d \n", card
->index
, (int)vpi
,
1269 if (vcc
->qos
.aal
!= ATM_AAL5
&& vcc
->qos
.aal
!= ATM_AAL0
) {
1270 PRINTK("nicstar%d: unsupported AAL.\n", card
->index
);
1274 vc
= &(card
->vcmap
[vpi
<< card
->vcibits
| vci
]);
1278 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
&& vc
->tx
)
1280 if (vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
&& vc
->rx
)
1283 printk("nicstar%d: %s vci already in use.\n", card
->index
,
1284 inuse
== 1 ? "tx" : inuse
== 2 ? "rx" : "tx and rx");
1288 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
1290 /* NOTE: You are not allowed to modify an open connection's QOS. To change
1291 that, remove the ATM_VF_PARTIAL flag checking. There may be other changes
1292 needed to do that. */
1293 if (!test_bit(ATM_VF_PARTIAL
, &vcc
->flags
)) {
1296 set_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1297 if (vcc
->qos
.txtp
.traffic_class
== ATM_CBR
) {
1298 /* Check requested cell rate and availability of SCD */
1299 if (vcc
->qos
.txtp
.max_pcr
== 0 && vcc
->qos
.txtp
.pcr
== 0
1300 && vcc
->qos
.txtp
.min_pcr
== 0) {
1302 ("nicstar%d: trying to open a CBR vc with cell rate = 0 \n",
1304 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1305 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1309 tcr
= atm_pcr_goal(&(vcc
->qos
.txtp
));
1310 tcra
= tcr
>= 0 ? tcr
: -tcr
;
1312 PRINTK("nicstar%d: target cell rate = %d.\n",
1313 card
->index
, vcc
->qos
.txtp
.max_pcr
);
1316 (unsigned long)tcra
*(unsigned long)
1318 modl
= tmpl
% card
->max_pcr
;
1320 n
= (int)(tmpl
/ card
->max_pcr
);
1324 } else if (tcr
== 0) {
1326 (card
->tst_free_entries
-
1327 NS_TST_RESERVED
)) <= 0) {
1329 ("nicstar%d: no CBR bandwidth free.\n",
1331 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1332 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1339 ("nicstar%d: selected bandwidth < granularity.\n",
1341 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1342 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1346 if (n
> (card
->tst_free_entries
- NS_TST_RESERVED
)) {
1348 ("nicstar%d: not enough free CBR bandwidth.\n",
1350 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1351 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1354 card
->tst_free_entries
-= n
;
1356 XPRINTK("nicstar%d: writing %d tst entries.\n",
1358 for (frscdi
= 0; frscdi
< NS_FRSCD_NUM
; frscdi
++) {
1359 if (card
->scd2vc
[frscdi
] == NULL
) {
1360 card
->scd2vc
[frscdi
] = vc
;
1364 if (frscdi
== NS_FRSCD_NUM
) {
1366 ("nicstar%d: no SCD available for CBR channel.\n",
1368 card
->tst_free_entries
+= n
;
1369 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1370 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1374 vc
->cbr_scd
= NS_FRSCD
+ frscdi
* NS_FRSCD_SIZE
;
1376 scq
= get_scq(card
, CBR_SCQSIZE
, vc
->cbr_scd
);
1378 PRINTK("nicstar%d: can't get fixed rate SCQ.\n",
1380 card
->scd2vc
[frscdi
] = NULL
;
1381 card
->tst_free_entries
+= n
;
1382 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1383 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1387 u32d
[0] = scq_virt_to_bus(scq
, scq
->base
);
1388 u32d
[1] = (u32
) 0x00000000;
1389 u32d
[2] = (u32
) 0xffffffff;
1390 u32d
[3] = (u32
) 0x00000000;
1391 ns_write_sram(card
, vc
->cbr_scd
, u32d
, 4);
1393 fill_tst(card
, n
, vc
);
1394 } else if (vcc
->qos
.txtp
.traffic_class
== ATM_UBR
) {
1395 vc
->cbr_scd
= 0x00000000;
1396 vc
->scq
= card
->scq0
;
1399 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
) {
1404 if (vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
) {
1411 /* Open the connection in hardware */
1412 if (vcc
->qos
.aal
== ATM_AAL5
)
1413 status
= NS_RCTE_AAL5
| NS_RCTE_CONNECTOPEN
;
1414 else /* vcc->qos.aal == ATM_AAL0 */
1415 status
= NS_RCTE_AAL0
| NS_RCTE_CONNECTOPEN
;
1417 status
|= NS_RCTE_RAWCELLINTEN
;
1418 #endif /* RCQ_SUPPORT */
1421 (vpi
<< card
->vcibits
| vci
) *
1422 NS_RCT_ENTRY_SIZE
, &status
, 1);
1427 set_bit(ATM_VF_READY
, &vcc
->flags
);
1431 static void ns_close(struct atm_vcc
*vcc
)
1439 card
= vcc
->dev
->dev_data
;
1440 PRINTK("nicstar%d: closing vpi.vci %d.%d \n", card
->index
,
1441 (int)vcc
->vpi
, vcc
->vci
);
1443 clear_bit(ATM_VF_READY
, &vcc
->flags
);
1445 if (vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
) {
1447 unsigned long flags
;
1451 (vcc
->vpi
<< card
->vcibits
| vcc
->vci
) * NS_RCT_ENTRY_SIZE
;
1452 spin_lock_irqsave(&card
->res_lock
, flags
);
1453 while (CMD_BUSY(card
)) ;
1454 writel(NS_CMD_CLOSE_CONNECTION
| addr
<< 2,
1455 card
->membase
+ CMD
);
1456 spin_unlock_irqrestore(&card
->res_lock
, flags
);
1459 if (vc
->rx_iov
!= NULL
) {
1460 struct sk_buff
*iovb
;
1463 stat
= readl(card
->membase
+ STAT
);
1464 card
->sbfqc
= ns_stat_sfbqc_get(stat
);
1465 card
->lbfqc
= ns_stat_lfbqc_get(stat
);
1468 ("nicstar%d: closing a VC with pending rx buffers.\n",
1471 recycle_iovec_rx_bufs(card
, (struct iovec
*)iovb
->data
,
1472 NS_PRV_IOVCNT(iovb
));
1473 NS_PRV_IOVCNT(iovb
) = 0;
1474 spin_lock_irqsave(&card
->int_lock
, flags
);
1475 recycle_iov_buf(card
, iovb
);
1476 spin_unlock_irqrestore(&card
->int_lock
, flags
);
1481 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
) {
1485 if (vcc
->qos
.txtp
.traffic_class
== ATM_CBR
) {
1486 unsigned long flags
;
1493 spin_lock_irqsave(&scq
->lock
, flags
);
1495 if (scqep
== scq
->base
)
1499 if (scqep
== scq
->tail
) {
1500 spin_unlock_irqrestore(&scq
->lock
, flags
);
1503 /* If the last entry is not a TSR, place one in the SCQ in order to
1504 be able to completely drain it and then close. */
1505 if (!ns_scqe_is_tsr(scqep
) && scq
->tail
!= scq
->next
) {
1511 tsr
.word_1
= ns_tsr_mkword_1(NS_TSR_INTENABLE
);
1512 scdi
= (vc
->cbr_scd
- NS_FRSCD
) / NS_FRSCD_SIZE
;
1513 scqi
= scq
->next
- scq
->base
;
1514 tsr
.word_2
= ns_tsr_mkword_2(scdi
, scqi
);
1515 tsr
.word_3
= 0x00000000;
1516 tsr
.word_4
= 0x00000000;
1519 scq
->skb
[index
] = NULL
;
1520 if (scq
->next
== scq
->last
)
1521 scq
->next
= scq
->base
;
1524 data
= scq_virt_to_bus(scq
, scq
->next
);
1525 ns_write_sram(card
, scq
->scd
, &data
, 1);
1527 spin_unlock_irqrestore(&scq
->lock
, flags
);
1531 /* Free all TST entries */
1532 data
= NS_TST_OPCODE_VARIABLE
;
1533 for (i
= 0; i
< NS_TST_NUM_ENTRIES
; i
++) {
1534 if (card
->tste2vc
[i
] == vc
) {
1535 ns_write_sram(card
, card
->tst_addr
+ i
, &data
,
1537 card
->tste2vc
[i
] = NULL
;
1538 card
->tst_free_entries
++;
1542 card
->scd2vc
[(vc
->cbr_scd
- NS_FRSCD
) / NS_FRSCD_SIZE
] = NULL
;
1543 free_scq(card
, vc
->scq
, vcc
);
1546 /* remove all references to vcc before deleting it */
1547 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
) {
1548 unsigned long flags
;
1549 scq_info
*scq
= card
->scq0
;
1551 spin_lock_irqsave(&scq
->lock
, flags
);
1553 for (i
= 0; i
< scq
->num_entries
; i
++) {
1554 if (scq
->skb
[i
] && ATM_SKB(scq
->skb
[i
])->vcc
== vcc
) {
1555 ATM_SKB(scq
->skb
[i
])->vcc
= NULL
;
1556 atm_return(vcc
, scq
->skb
[i
]->truesize
);
1558 ("nicstar: deleted pending vcc mapping\n");
1562 spin_unlock_irqrestore(&scq
->lock
, flags
);
1565 vcc
->dev_data
= NULL
;
1566 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
1567 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
1572 stat
= readl(card
->membase
+ STAT
);
1573 cfg
= readl(card
->membase
+ CFG
);
1574 printk("STAT = 0x%08X CFG = 0x%08X \n", stat
, cfg
);
1576 ("TSQ: base = 0x%p next = 0x%p last = 0x%p TSQT = 0x%08X \n",
1577 card
->tsq
.base
, card
->tsq
.next
,
1578 card
->tsq
.last
, readl(card
->membase
+ TSQT
));
1580 ("RSQ: base = 0x%p next = 0x%p last = 0x%p RSQT = 0x%08X \n",
1581 card
->rsq
.base
, card
->rsq
.next
,
1582 card
->rsq
.last
, readl(card
->membase
+ RSQT
));
1583 printk("Empty free buffer queue interrupt %s \n",
1584 card
->efbie
? "enabled" : "disabled");
1585 printk("SBCNT = %d count = %d LBCNT = %d count = %d \n",
1586 ns_stat_sfbqc_get(stat
), card
->sbpool
.count
,
1587 ns_stat_lfbqc_get(stat
), card
->lbpool
.count
);
1588 printk("hbpool.count = %d iovpool.count = %d \n",
1589 card
->hbpool
.count
, card
->iovpool
.count
);
1591 #endif /* RX_DEBUG */
1594 static void fill_tst(ns_dev
* card
, int n
, vc_map
* vc
)
1601 /* It would be very complicated to keep the two TSTs synchronized while
1602 assuring that writes are only made to the inactive TST. So, for now I
1603 will use only one TST. If problems occur, I will change this again */
1605 new_tst
= card
->tst_addr
;
1607 /* Fill procedure */
1609 for (e
= 0; e
< NS_TST_NUM_ENTRIES
; e
++) {
1610 if (card
->tste2vc
[e
] == NULL
)
1613 if (e
== NS_TST_NUM_ENTRIES
) {
1614 printk("nicstar%d: No free TST entries found. \n", card
->index
);
1619 cl
= NS_TST_NUM_ENTRIES
;
1620 data
= ns_tste_make(NS_TST_OPCODE_FIXED
, vc
->cbr_scd
);
1623 if (cl
>= NS_TST_NUM_ENTRIES
&& card
->tste2vc
[e
] == NULL
) {
1624 card
->tste2vc
[e
] = vc
;
1625 ns_write_sram(card
, new_tst
+ e
, &data
, 1);
1626 cl
-= NS_TST_NUM_ENTRIES
;
1630 if (++e
== NS_TST_NUM_ENTRIES
) {
1636 /* End of fill procedure */
1638 data
= ns_tste_make(NS_TST_OPCODE_END
, new_tst
);
1639 ns_write_sram(card
, new_tst
+ NS_TST_NUM_ENTRIES
, &data
, 1);
1640 ns_write_sram(card
, card
->tst_addr
+ NS_TST_NUM_ENTRIES
, &data
, 1);
1641 card
->tst_addr
= new_tst
;
1644 static int ns_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
1649 unsigned long buflen
;
1651 u32 flags
; /* TBD flags, not CPU flags */
1653 card
= vcc
->dev
->dev_data
;
1654 TXPRINTK("nicstar%d: ns_send() called.\n", card
->index
);
1655 if ((vc
= (vc_map
*) vcc
->dev_data
) == NULL
) {
1656 printk("nicstar%d: vcc->dev_data == NULL on ns_send().\n",
1658 atomic_inc(&vcc
->stats
->tx_err
);
1659 dev_kfree_skb_any(skb
);
1664 printk("nicstar%d: Trying to transmit on a non-tx VC.\n",
1666 atomic_inc(&vcc
->stats
->tx_err
);
1667 dev_kfree_skb_any(skb
);
1671 if (vcc
->qos
.aal
!= ATM_AAL5
&& vcc
->qos
.aal
!= ATM_AAL0
) {
1672 printk("nicstar%d: Only AAL0 and AAL5 are supported.\n",
1674 atomic_inc(&vcc
->stats
->tx_err
);
1675 dev_kfree_skb_any(skb
);
1679 if (skb_shinfo(skb
)->nr_frags
!= 0) {
1680 printk("nicstar%d: No scatter-gather yet.\n", card
->index
);
1681 atomic_inc(&vcc
->stats
->tx_err
);
1682 dev_kfree_skb_any(skb
);
1686 ATM_SKB(skb
)->vcc
= vcc
;
1688 NS_PRV_DMA(skb
) = pci_map_single(card
->pcidev
, skb
->data
,
1689 skb
->len
, PCI_DMA_TODEVICE
);
1691 if (vcc
->qos
.aal
== ATM_AAL5
) {
1692 buflen
= (skb
->len
+ 47 + 8) / 48 * 48; /* Multiple of 48 */
1693 flags
= NS_TBD_AAL5
;
1694 scqe
.word_2
= cpu_to_le32(NS_PRV_DMA(skb
));
1695 scqe
.word_3
= cpu_to_le32(skb
->len
);
1697 ns_tbd_mkword_4(0, (u32
) vcc
->vpi
, (u32
) vcc
->vci
, 0,
1699 atm_options
& ATM_ATMOPT_CLP
? 1 : 0);
1700 flags
|= NS_TBD_EOPDU
;
1701 } else { /* (vcc->qos.aal == ATM_AAL0) */
1703 buflen
= ATM_CELL_PAYLOAD
; /* i.e., 48 bytes */
1704 flags
= NS_TBD_AAL0
;
1705 scqe
.word_2
= cpu_to_le32(NS_PRV_DMA(skb
) + NS_AAL0_HEADER
);
1706 scqe
.word_3
= cpu_to_le32(0x00000000);
1707 if (*skb
->data
& 0x02) /* Payload type 1 - end of pdu */
1708 flags
|= NS_TBD_EOPDU
;
1710 cpu_to_le32(*((u32
*) skb
->data
) & ~NS_TBD_VC_MASK
);
1711 /* Force the VPI/VCI to be the same as in VCC struct */
1713 cpu_to_le32((((u32
) vcc
->
1714 vpi
) << NS_TBD_VPI_SHIFT
| ((u32
) vcc
->
1716 NS_TBD_VCI_SHIFT
) & NS_TBD_VC_MASK
);
1719 if (vcc
->qos
.txtp
.traffic_class
== ATM_CBR
) {
1720 scqe
.word_1
= ns_tbd_mkword_1_novbr(flags
, (u32
) buflen
);
1721 scq
= ((vc_map
*) vcc
->dev_data
)->scq
;
1724 ns_tbd_mkword_1(flags
, (u32
) 1, (u32
) 1, (u32
) buflen
);
1728 if (push_scqe(card
, vc
, scq
, &scqe
, skb
) != 0) {
1729 atomic_inc(&vcc
->stats
->tx_err
);
1730 dev_kfree_skb_any(skb
);
1733 atomic_inc(&vcc
->stats
->tx
);
1738 static int push_scqe(ns_dev
* card
, vc_map
* vc
, scq_info
* scq
, ns_scqe
* tbd
,
1739 struct sk_buff
*skb
)
1741 unsigned long flags
;
1748 spin_lock_irqsave(&scq
->lock
, flags
);
1749 while (scq
->tail
== scq
->next
) {
1750 if (in_interrupt()) {
1751 spin_unlock_irqrestore(&scq
->lock
, flags
);
1752 printk("nicstar%d: Error pushing TBD.\n", card
->index
);
1757 spin_unlock_irqrestore(&scq
->lock
, flags
);
1758 interruptible_sleep_on_timeout(&scq
->scqfull_waitq
,
1760 spin_lock_irqsave(&scq
->lock
, flags
);
1763 spin_unlock_irqrestore(&scq
->lock
, flags
);
1764 printk("nicstar%d: Timeout pushing TBD.\n",
1770 index
= (int)(scq
->next
- scq
->base
);
1771 scq
->skb
[index
] = skb
;
1772 XPRINTK("nicstar%d: sending skb at 0x%p (pos %d).\n",
1773 card
->index
, skb
, index
);
1774 XPRINTK("nicstar%d: TBD written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%p.\n",
1775 card
->index
, le32_to_cpu(tbd
->word_1
), le32_to_cpu(tbd
->word_2
),
1776 le32_to_cpu(tbd
->word_3
), le32_to_cpu(tbd
->word_4
),
1778 if (scq
->next
== scq
->last
)
1779 scq
->next
= scq
->base
;
1784 if (scq
->num_entries
== VBR_SCQ_NUM_ENTRIES
) {
1790 if (vc
->tbd_count
>= MAX_TBD_PER_VC
1791 || scq
->tbd_count
>= MAX_TBD_PER_SCQ
) {
1794 while (scq
->tail
== scq
->next
) {
1795 if (in_interrupt()) {
1796 data
= scq_virt_to_bus(scq
, scq
->next
);
1797 ns_write_sram(card
, scq
->scd
, &data
, 1);
1798 spin_unlock_irqrestore(&scq
->lock
, flags
);
1799 printk("nicstar%d: Error pushing TSR.\n",
1807 spin_unlock_irqrestore(&scq
->lock
, flags
);
1808 interruptible_sleep_on_timeout(&scq
->scqfull_waitq
,
1810 spin_lock_irqsave(&scq
->lock
, flags
);
1814 tsr
.word_1
= ns_tsr_mkword_1(NS_TSR_INTENABLE
);
1816 scdi
= NS_TSR_SCDISVBR
;
1818 scdi
= (vc
->cbr_scd
- NS_FRSCD
) / NS_FRSCD_SIZE
;
1819 scqi
= scq
->next
- scq
->base
;
1820 tsr
.word_2
= ns_tsr_mkword_2(scdi
, scqi
);
1821 tsr
.word_3
= 0x00000000;
1822 tsr
.word_4
= 0x00000000;
1826 scq
->skb
[index
] = NULL
;
1828 ("nicstar%d: TSR written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%p.\n",
1829 card
->index
, le32_to_cpu(tsr
.word_1
),
1830 le32_to_cpu(tsr
.word_2
), le32_to_cpu(tsr
.word_3
),
1831 le32_to_cpu(tsr
.word_4
), scq
->next
);
1832 if (scq
->next
== scq
->last
)
1833 scq
->next
= scq
->base
;
1839 PRINTK("nicstar%d: Timeout pushing TSR.\n",
1842 data
= scq_virt_to_bus(scq
, scq
->next
);
1843 ns_write_sram(card
, scq
->scd
, &data
, 1);
1845 spin_unlock_irqrestore(&scq
->lock
, flags
);
1850 static void process_tsq(ns_dev
* card
)
1854 ns_tsi
*previous
= NULL
, *one_ahead
, *two_ahead
;
1855 int serviced_entries
; /* flag indicating at least on entry was serviced */
1857 serviced_entries
= 0;
1859 if (card
->tsq
.next
== card
->tsq
.last
)
1860 one_ahead
= card
->tsq
.base
;
1862 one_ahead
= card
->tsq
.next
+ 1;
1864 if (one_ahead
== card
->tsq
.last
)
1865 two_ahead
= card
->tsq
.base
;
1867 two_ahead
= one_ahead
+ 1;
1869 while (!ns_tsi_isempty(card
->tsq
.next
) || !ns_tsi_isempty(one_ahead
) ||
1870 !ns_tsi_isempty(two_ahead
))
1871 /* At most two empty, as stated in the 77201 errata */
1873 serviced_entries
= 1;
1875 /* Skip the one or two possible empty entries */
1876 while (ns_tsi_isempty(card
->tsq
.next
)) {
1877 if (card
->tsq
.next
== card
->tsq
.last
)
1878 card
->tsq
.next
= card
->tsq
.base
;
1883 if (!ns_tsi_tmrof(card
->tsq
.next
)) {
1884 scdi
= ns_tsi_getscdindex(card
->tsq
.next
);
1885 if (scdi
== NS_TSI_SCDISVBR
)
1888 if (card
->scd2vc
[scdi
] == NULL
) {
1890 ("nicstar%d: could not find VC from SCD index.\n",
1892 ns_tsi_init(card
->tsq
.next
);
1895 scq
= card
->scd2vc
[scdi
]->scq
;
1897 drain_scq(card
, scq
, ns_tsi_getscqpos(card
->tsq
.next
));
1899 wake_up_interruptible(&(scq
->scqfull_waitq
));
1902 ns_tsi_init(card
->tsq
.next
);
1903 previous
= card
->tsq
.next
;
1904 if (card
->tsq
.next
== card
->tsq
.last
)
1905 card
->tsq
.next
= card
->tsq
.base
;
1909 if (card
->tsq
.next
== card
->tsq
.last
)
1910 one_ahead
= card
->tsq
.base
;
1912 one_ahead
= card
->tsq
.next
+ 1;
1914 if (one_ahead
== card
->tsq
.last
)
1915 two_ahead
= card
->tsq
.base
;
1917 two_ahead
= one_ahead
+ 1;
1920 if (serviced_entries
)
1921 writel(PTR_DIFF(previous
, card
->tsq
.base
),
1922 card
->membase
+ TSQH
);
1925 static void drain_scq(ns_dev
* card
, scq_info
* scq
, int pos
)
1927 struct atm_vcc
*vcc
;
1928 struct sk_buff
*skb
;
1930 unsigned long flags
;
1932 XPRINTK("nicstar%d: drain_scq() called, scq at 0x%p, pos %d.\n",
1933 card
->index
, scq
, pos
);
1934 if (pos
>= scq
->num_entries
) {
1935 printk("nicstar%d: Bad index on drain_scq().\n", card
->index
);
1939 spin_lock_irqsave(&scq
->lock
, flags
);
1940 i
= (int)(scq
->tail
- scq
->base
);
1941 if (++i
== scq
->num_entries
)
1945 XPRINTK("nicstar%d: freeing skb at 0x%p (index %d).\n",
1946 card
->index
, skb
, i
);
1948 pci_unmap_single(card
->pcidev
,
1952 vcc
= ATM_SKB(skb
)->vcc
;
1953 if (vcc
&& vcc
->pop
!= NULL
) {
1956 dev_kfree_skb_irq(skb
);
1960 if (++i
== scq
->num_entries
)
1963 scq
->tail
= scq
->base
+ pos
;
1964 spin_unlock_irqrestore(&scq
->lock
, flags
);
1967 static void process_rsq(ns_dev
* card
)
1971 if (!ns_rsqe_valid(card
->rsq
.next
))
1974 dequeue_rx(card
, card
->rsq
.next
);
1975 ns_rsqe_init(card
->rsq
.next
);
1976 previous
= card
->rsq
.next
;
1977 if (card
->rsq
.next
== card
->rsq
.last
)
1978 card
->rsq
.next
= card
->rsq
.base
;
1981 } while (ns_rsqe_valid(card
->rsq
.next
));
1982 writel(PTR_DIFF(previous
, card
->rsq
.base
), card
->membase
+ RSQH
);
1985 static void dequeue_rx(ns_dev
* card
, ns_rsqe
* rsqe
)
1989 struct sk_buff
*iovb
;
1991 struct atm_vcc
*vcc
;
1992 struct sk_buff
*skb
;
1993 unsigned short aal5_len
;
1998 stat
= readl(card
->membase
+ STAT
);
1999 card
->sbfqc
= ns_stat_sfbqc_get(stat
);
2000 card
->lbfqc
= ns_stat_lfbqc_get(stat
);
2002 id
= le32_to_cpu(rsqe
->buffer_handle
);
2003 skb
= idr_find(&card
->idr
, id
);
2006 "nicstar%d: idr_find() failed!\n", card
->index
);
2009 idr_remove(&card
->idr
, id
);
2010 pci_dma_sync_single_for_cpu(card
->pcidev
,
2012 (NS_PRV_BUFTYPE(skb
) == BUF_SM
2013 ? NS_SMSKBSIZE
: NS_LGSKBSIZE
),
2014 PCI_DMA_FROMDEVICE
);
2015 pci_unmap_single(card
->pcidev
,
2017 (NS_PRV_BUFTYPE(skb
) == BUF_SM
2018 ? NS_SMSKBSIZE
: NS_LGSKBSIZE
),
2019 PCI_DMA_FROMDEVICE
);
2020 vpi
= ns_rsqe_vpi(rsqe
);
2021 vci
= ns_rsqe_vci(rsqe
);
2022 if (vpi
>= 1UL << card
->vpibits
|| vci
>= 1UL << card
->vcibits
) {
2023 printk("nicstar%d: SDU received for out-of-range vc %d.%d.\n",
2024 card
->index
, vpi
, vci
);
2025 recycle_rx_buf(card
, skb
);
2029 vc
= &(card
->vcmap
[vpi
<< card
->vcibits
| vci
]);
2031 RXPRINTK("nicstar%d: SDU received on non-rx vc %d.%d.\n",
2032 card
->index
, vpi
, vci
);
2033 recycle_rx_buf(card
, skb
);
2039 if (vcc
->qos
.aal
== ATM_AAL0
) {
2041 unsigned char *cell
;
2045 for (i
= ns_rsqe_cellcount(rsqe
); i
; i
--) {
2046 if ((sb
= dev_alloc_skb(NS_SMSKBSIZE
)) == NULL
) {
2048 ("nicstar%d: Can't allocate buffers for aal0.\n",
2050 atomic_add(i
, &vcc
->stats
->rx_drop
);
2053 if (!atm_charge(vcc
, sb
->truesize
)) {
2055 ("nicstar%d: atm_charge() dropped aal0 packets.\n",
2057 atomic_add(i
- 1, &vcc
->stats
->rx_drop
); /* already increased by 1 */
2058 dev_kfree_skb_any(sb
);
2061 /* Rebuild the header */
2062 *((u32
*) sb
->data
) = le32_to_cpu(rsqe
->word_1
) << 4 |
2063 (ns_rsqe_clp(rsqe
) ? 0x00000001 : 0x00000000);
2064 if (i
== 1 && ns_rsqe_eopdu(rsqe
))
2065 *((u32
*) sb
->data
) |= 0x00000002;
2066 skb_put(sb
, NS_AAL0_HEADER
);
2067 memcpy(skb_tail_pointer(sb
), cell
, ATM_CELL_PAYLOAD
);
2068 skb_put(sb
, ATM_CELL_PAYLOAD
);
2069 ATM_SKB(sb
)->vcc
= vcc
;
2070 __net_timestamp(sb
);
2072 atomic_inc(&vcc
->stats
->rx
);
2073 cell
+= ATM_CELL_PAYLOAD
;
2076 recycle_rx_buf(card
, skb
);
2080 /* To reach this point, the AAL layer can only be AAL5 */
2082 if ((iovb
= vc
->rx_iov
) == NULL
) {
2083 iovb
= skb_dequeue(&(card
->iovpool
.queue
));
2084 if (iovb
== NULL
) { /* No buffers in the queue */
2085 iovb
= alloc_skb(NS_IOVBUFSIZE
, GFP_ATOMIC
);
2087 printk("nicstar%d: Out of iovec buffers.\n",
2089 atomic_inc(&vcc
->stats
->rx_drop
);
2090 recycle_rx_buf(card
, skb
);
2093 NS_PRV_BUFTYPE(iovb
) = BUF_NONE
;
2094 } else if (--card
->iovpool
.count
< card
->iovnr
.min
) {
2095 struct sk_buff
*new_iovb
;
2097 alloc_skb(NS_IOVBUFSIZE
, GFP_ATOMIC
)) != NULL
) {
2098 NS_PRV_BUFTYPE(iovb
) = BUF_NONE
;
2099 skb_queue_tail(&card
->iovpool
.queue
, new_iovb
);
2100 card
->iovpool
.count
++;
2104 NS_PRV_IOVCNT(iovb
) = 0;
2106 iovb
->data
= iovb
->head
;
2107 skb_reset_tail_pointer(iovb
);
2108 /* IMPORTANT: a pointer to the sk_buff containing the small or large
2109 buffer is stored as iovec base, NOT a pointer to the
2110 small or large buffer itself. */
2111 } else if (NS_PRV_IOVCNT(iovb
) >= NS_MAX_IOVECS
) {
2112 printk("nicstar%d: received too big AAL5 SDU.\n", card
->index
);
2113 atomic_inc(&vcc
->stats
->rx_err
);
2114 recycle_iovec_rx_bufs(card
, (struct iovec
*)iovb
->data
,
2116 NS_PRV_IOVCNT(iovb
) = 0;
2118 iovb
->data
= iovb
->head
;
2119 skb_reset_tail_pointer(iovb
);
2121 iov
= &((struct iovec
*)iovb
->data
)[NS_PRV_IOVCNT(iovb
)++];
2122 iov
->iov_base
= (void *)skb
;
2123 iov
->iov_len
= ns_rsqe_cellcount(rsqe
) * 48;
2124 iovb
->len
+= iov
->iov_len
;
2127 if (NS_PRV_IOVCNT(iovb
) == 1) {
2128 if (NS_PRV_BUFTYPE(skb
) != BUF_SM
) {
2130 ("nicstar%d: Expected a small buffer, and this is not one.\n",
2132 which_list(card
, skb
);
2133 atomic_inc(&vcc
->stats
->rx_err
);
2134 recycle_rx_buf(card
, skb
);
2136 recycle_iov_buf(card
, iovb
);
2139 } else { /* NS_PRV_IOVCNT(iovb) >= 2 */
2141 if (NS_PRV_BUFTYPE(skb
) != BUF_LG
) {
2143 ("nicstar%d: Expected a large buffer, and this is not one.\n",
2145 which_list(card
, skb
);
2146 atomic_inc(&vcc
->stats
->rx_err
);
2147 recycle_iovec_rx_bufs(card
, (struct iovec
*)iovb
->data
,
2148 NS_PRV_IOVCNT(iovb
));
2150 recycle_iov_buf(card
, iovb
);
2154 #endif /* EXTRA_DEBUG */
2156 if (ns_rsqe_eopdu(rsqe
)) {
2157 /* This works correctly regardless of the endianness of the host */
2158 unsigned char *L1L2
= (unsigned char *)
2159 (skb
->data
+ iov
->iov_len
- 6);
2160 aal5_len
= L1L2
[0] << 8 | L1L2
[1];
2161 len
= (aal5_len
== 0x0000) ? 0x10000 : aal5_len
;
2162 if (ns_rsqe_crcerr(rsqe
) ||
2163 len
+ 8 > iovb
->len
|| len
+ (47 + 8) < iovb
->len
) {
2164 printk("nicstar%d: AAL5 CRC error", card
->index
);
2165 if (len
+ 8 > iovb
->len
|| len
+ (47 + 8) < iovb
->len
)
2166 printk(" - PDU size mismatch.\n");
2169 atomic_inc(&vcc
->stats
->rx_err
);
2170 recycle_iovec_rx_bufs(card
, (struct iovec
*)iovb
->data
,
2171 NS_PRV_IOVCNT(iovb
));
2173 recycle_iov_buf(card
, iovb
);
2177 /* By this point we (hopefully) have a complete SDU without errors. */
2179 if (NS_PRV_IOVCNT(iovb
) == 1) { /* Just a small buffer */
2180 /* skb points to a small buffer */
2181 if (!atm_charge(vcc
, skb
->truesize
)) {
2182 push_rxbufs(card
, skb
);
2183 atomic_inc(&vcc
->stats
->rx_drop
);
2186 dequeue_sm_buf(card
, skb
);
2187 #ifdef NS_USE_DESTRUCTORS
2188 skb
->destructor
= ns_sb_destructor
;
2189 #endif /* NS_USE_DESTRUCTORS */
2190 ATM_SKB(skb
)->vcc
= vcc
;
2191 __net_timestamp(skb
);
2192 vcc
->push(vcc
, skb
);
2193 atomic_inc(&vcc
->stats
->rx
);
2195 } else if (NS_PRV_IOVCNT(iovb
) == 2) { /* One small plus one large buffer */
2198 sb
= (struct sk_buff
*)(iov
- 1)->iov_base
;
2199 /* skb points to a large buffer */
2201 if (len
<= NS_SMBUFSIZE
) {
2202 if (!atm_charge(vcc
, sb
->truesize
)) {
2203 push_rxbufs(card
, sb
);
2204 atomic_inc(&vcc
->stats
->rx_drop
);
2207 dequeue_sm_buf(card
, sb
);
2208 #ifdef NS_USE_DESTRUCTORS
2209 sb
->destructor
= ns_sb_destructor
;
2210 #endif /* NS_USE_DESTRUCTORS */
2211 ATM_SKB(sb
)->vcc
= vcc
;
2212 __net_timestamp(sb
);
2214 atomic_inc(&vcc
->stats
->rx
);
2217 push_rxbufs(card
, skb
);
2219 } else { /* len > NS_SMBUFSIZE, the usual case */
2221 if (!atm_charge(vcc
, skb
->truesize
)) {
2222 push_rxbufs(card
, skb
);
2223 atomic_inc(&vcc
->stats
->rx_drop
);
2225 dequeue_lg_buf(card
, skb
);
2226 #ifdef NS_USE_DESTRUCTORS
2227 skb
->destructor
= ns_lb_destructor
;
2228 #endif /* NS_USE_DESTRUCTORS */
2229 skb_push(skb
, NS_SMBUFSIZE
);
2230 skb_copy_from_linear_data(sb
, skb
->data
,
2232 skb_put(skb
, len
- NS_SMBUFSIZE
);
2233 ATM_SKB(skb
)->vcc
= vcc
;
2234 __net_timestamp(skb
);
2235 vcc
->push(vcc
, skb
);
2236 atomic_inc(&vcc
->stats
->rx
);
2239 push_rxbufs(card
, sb
);
2243 } else { /* Must push a huge buffer */
2245 struct sk_buff
*hb
, *sb
, *lb
;
2246 int remaining
, tocopy
;
2249 hb
= skb_dequeue(&(card
->hbpool
.queue
));
2250 if (hb
== NULL
) { /* No buffers in the queue */
2252 hb
= dev_alloc_skb(NS_HBUFSIZE
);
2255 ("nicstar%d: Out of huge buffers.\n",
2257 atomic_inc(&vcc
->stats
->rx_drop
);
2258 recycle_iovec_rx_bufs(card
,
2261 NS_PRV_IOVCNT(iovb
));
2263 recycle_iov_buf(card
, iovb
);
2265 } else if (card
->hbpool
.count
< card
->hbnr
.min
) {
2266 struct sk_buff
*new_hb
;
2268 dev_alloc_skb(NS_HBUFSIZE
)) !=
2270 skb_queue_tail(&card
->hbpool
.
2272 card
->hbpool
.count
++;
2275 NS_PRV_BUFTYPE(hb
) = BUF_NONE
;
2276 } else if (--card
->hbpool
.count
< card
->hbnr
.min
) {
2277 struct sk_buff
*new_hb
;
2279 dev_alloc_skb(NS_HBUFSIZE
)) != NULL
) {
2280 NS_PRV_BUFTYPE(new_hb
) = BUF_NONE
;
2281 skb_queue_tail(&card
->hbpool
.queue
,
2283 card
->hbpool
.count
++;
2285 if (card
->hbpool
.count
< card
->hbnr
.min
) {
2287 dev_alloc_skb(NS_HBUFSIZE
)) !=
2289 NS_PRV_BUFTYPE(new_hb
) =
2291 skb_queue_tail(&card
->hbpool
.
2293 card
->hbpool
.count
++;
2298 iov
= (struct iovec
*)iovb
->data
;
2300 if (!atm_charge(vcc
, hb
->truesize
)) {
2301 recycle_iovec_rx_bufs(card
, iov
,
2302 NS_PRV_IOVCNT(iovb
));
2303 if (card
->hbpool
.count
< card
->hbnr
.max
) {
2304 skb_queue_tail(&card
->hbpool
.queue
, hb
);
2305 card
->hbpool
.count
++;
2307 dev_kfree_skb_any(hb
);
2308 atomic_inc(&vcc
->stats
->rx_drop
);
2310 /* Copy the small buffer to the huge buffer */
2311 sb
= (struct sk_buff
*)iov
->iov_base
;
2312 skb_copy_from_linear_data(sb
, hb
->data
,
2314 skb_put(hb
, iov
->iov_len
);
2315 remaining
= len
- iov
->iov_len
;
2317 /* Free the small buffer */
2318 push_rxbufs(card
, sb
);
2320 /* Copy all large buffers to the huge buffer and free them */
2321 for (j
= 1; j
< NS_PRV_IOVCNT(iovb
); j
++) {
2322 lb
= (struct sk_buff
*)iov
->iov_base
;
2324 min_t(int, remaining
, iov
->iov_len
);
2325 skb_copy_from_linear_data(lb
,
2328 skb_put(hb
, tocopy
);
2330 remaining
-= tocopy
;
2331 push_rxbufs(card
, lb
);
2334 if (remaining
!= 0 || hb
->len
!= len
)
2336 ("nicstar%d: Huge buffer len mismatch.\n",
2338 #endif /* EXTRA_DEBUG */
2339 ATM_SKB(hb
)->vcc
= vcc
;
2340 #ifdef NS_USE_DESTRUCTORS
2341 hb
->destructor
= ns_hb_destructor
;
2342 #endif /* NS_USE_DESTRUCTORS */
2343 __net_timestamp(hb
);
2345 atomic_inc(&vcc
->stats
->rx
);
2350 recycle_iov_buf(card
, iovb
);
2355 #ifdef NS_USE_DESTRUCTORS
2357 static void ns_sb_destructor(struct sk_buff
*sb
)
2362 card
= (ns_dev
*) ATM_SKB(sb
)->vcc
->dev
->dev_data
;
2363 stat
= readl(card
->membase
+ STAT
);
2364 card
->sbfqc
= ns_stat_sfbqc_get(stat
);
2365 card
->lbfqc
= ns_stat_lfbqc_get(stat
);
2368 sb
= __dev_alloc_skb(NS_SMSKBSIZE
, GFP_KERNEL
);
2371 NS_PRV_BUFTYPE(sb
) = BUF_SM
;
2372 skb_queue_tail(&card
->sbpool
.queue
, sb
);
2373 skb_reserve(sb
, NS_AAL0_HEADER
);
2374 push_rxbufs(card
, sb
);
2375 } while (card
->sbfqc
< card
->sbnr
.min
);
2378 static void ns_lb_destructor(struct sk_buff
*lb
)
2383 card
= (ns_dev
*) ATM_SKB(lb
)->vcc
->dev
->dev_data
;
2384 stat
= readl(card
->membase
+ STAT
);
2385 card
->sbfqc
= ns_stat_sfbqc_get(stat
);
2386 card
->lbfqc
= ns_stat_lfbqc_get(stat
);
2389 lb
= __dev_alloc_skb(NS_LGSKBSIZE
, GFP_KERNEL
);
2392 NS_PRV_BUFTYPE(lb
) = BUF_LG
;
2393 skb_queue_tail(&card
->lbpool
.queue
, lb
);
2394 skb_reserve(lb
, NS_SMBUFSIZE
);
2395 push_rxbufs(card
, lb
);
2396 } while (card
->lbfqc
< card
->lbnr
.min
);
2399 static void ns_hb_destructor(struct sk_buff
*hb
)
2403 card
= (ns_dev
*) ATM_SKB(hb
)->vcc
->dev
->dev_data
;
2405 while (card
->hbpool
.count
< card
->hbnr
.init
) {
2406 hb
= __dev_alloc_skb(NS_HBUFSIZE
, GFP_KERNEL
);
2409 NS_PRV_BUFTYPE(hb
) = BUF_NONE
;
2410 skb_queue_tail(&card
->hbpool
.queue
, hb
);
2411 card
->hbpool
.count
++;
2415 #endif /* NS_USE_DESTRUCTORS */
2417 static void recycle_rx_buf(ns_dev
* card
, struct sk_buff
*skb
)
2419 if (unlikely(NS_PRV_BUFTYPE(skb
) == BUF_NONE
)) {
2420 printk("nicstar%d: What kind of rx buffer is this?\n",
2422 dev_kfree_skb_any(skb
);
2424 push_rxbufs(card
, skb
);
2427 static void recycle_iovec_rx_bufs(ns_dev
* card
, struct iovec
*iov
, int count
)
2430 recycle_rx_buf(card
, (struct sk_buff
*)(iov
++)->iov_base
);
2433 static void recycle_iov_buf(ns_dev
* card
, struct sk_buff
*iovb
)
2435 if (card
->iovpool
.count
< card
->iovnr
.max
) {
2436 skb_queue_tail(&card
->iovpool
.queue
, iovb
);
2437 card
->iovpool
.count
++;
2439 dev_kfree_skb_any(iovb
);
2442 static void dequeue_sm_buf(ns_dev
* card
, struct sk_buff
*sb
)
2444 skb_unlink(sb
, &card
->sbpool
.queue
);
2445 #ifdef NS_USE_DESTRUCTORS
2446 if (card
->sbfqc
< card
->sbnr
.min
)
2448 if (card
->sbfqc
< card
->sbnr
.init
) {
2449 struct sk_buff
*new_sb
;
2450 if ((new_sb
= dev_alloc_skb(NS_SMSKBSIZE
)) != NULL
) {
2451 NS_PRV_BUFTYPE(new_sb
) = BUF_SM
;
2452 skb_queue_tail(&card
->sbpool
.queue
, new_sb
);
2453 skb_reserve(new_sb
, NS_AAL0_HEADER
);
2454 push_rxbufs(card
, new_sb
);
2457 if (card
->sbfqc
< card
->sbnr
.init
)
2458 #endif /* NS_USE_DESTRUCTORS */
2460 struct sk_buff
*new_sb
;
2461 if ((new_sb
= dev_alloc_skb(NS_SMSKBSIZE
)) != NULL
) {
2462 NS_PRV_BUFTYPE(new_sb
) = BUF_SM
;
2463 skb_queue_tail(&card
->sbpool
.queue
, new_sb
);
2464 skb_reserve(new_sb
, NS_AAL0_HEADER
);
2465 push_rxbufs(card
, new_sb
);
2470 static void dequeue_lg_buf(ns_dev
* card
, struct sk_buff
*lb
)
2472 skb_unlink(lb
, &card
->lbpool
.queue
);
2473 #ifdef NS_USE_DESTRUCTORS
2474 if (card
->lbfqc
< card
->lbnr
.min
)
2476 if (card
->lbfqc
< card
->lbnr
.init
) {
2477 struct sk_buff
*new_lb
;
2478 if ((new_lb
= dev_alloc_skb(NS_LGSKBSIZE
)) != NULL
) {
2479 NS_PRV_BUFTYPE(new_lb
) = BUF_LG
;
2480 skb_queue_tail(&card
->lbpool
.queue
, new_lb
);
2481 skb_reserve(new_lb
, NS_SMBUFSIZE
);
2482 push_rxbufs(card
, new_lb
);
2485 if (card
->lbfqc
< card
->lbnr
.init
)
2486 #endif /* NS_USE_DESTRUCTORS */
2488 struct sk_buff
*new_lb
;
2489 if ((new_lb
= dev_alloc_skb(NS_LGSKBSIZE
)) != NULL
) {
2490 NS_PRV_BUFTYPE(new_lb
) = BUF_LG
;
2491 skb_queue_tail(&card
->lbpool
.queue
, new_lb
);
2492 skb_reserve(new_lb
, NS_SMBUFSIZE
);
2493 push_rxbufs(card
, new_lb
);
2498 static int ns_proc_read(struct atm_dev
*dev
, loff_t
* pos
, char *page
)
2505 card
= (ns_dev
*) dev
->dev_data
;
2506 stat
= readl(card
->membase
+ STAT
);
2508 return sprintf(page
, "Pool count min init max \n");
2510 return sprintf(page
, "Small %5d %5d %5d %5d \n",
2511 ns_stat_sfbqc_get(stat
), card
->sbnr
.min
,
2512 card
->sbnr
.init
, card
->sbnr
.max
);
2514 return sprintf(page
, "Large %5d %5d %5d %5d \n",
2515 ns_stat_lfbqc_get(stat
), card
->lbnr
.min
,
2516 card
->lbnr
.init
, card
->lbnr
.max
);
2518 return sprintf(page
, "Huge %5d %5d %5d %5d \n",
2519 card
->hbpool
.count
, card
->hbnr
.min
,
2520 card
->hbnr
.init
, card
->hbnr
.max
);
2522 return sprintf(page
, "Iovec %5d %5d %5d %5d \n",
2523 card
->iovpool
.count
, card
->iovnr
.min
,
2524 card
->iovnr
.init
, card
->iovnr
.max
);
2528 sprintf(page
, "Interrupt counter: %u \n", card
->intcnt
);
2533 /* Dump 25.6 Mbps PHY registers */
2534 /* Now there's a 25.6 Mbps PHY driver this code isn't needed. I left it
2535 here just in case it's needed for debugging. */
2536 if (card
->max_pcr
== ATM_25_PCR
&& !left
--) {
2540 for (i
= 0; i
< 4; i
++) {
2541 while (CMD_BUSY(card
)) ;
2542 writel(NS_CMD_READ_UTILITY
| 0x00000200 | i
,
2543 card
->membase
+ CMD
);
2544 while (CMD_BUSY(card
)) ;
2545 phy_regs
[i
] = readl(card
->membase
+ DR0
) & 0x000000FF;
2548 return sprintf(page
, "PHY regs: 0x%02X 0x%02X 0x%02X 0x%02X \n",
2549 phy_regs
[0], phy_regs
[1], phy_regs
[2],
2552 #endif /* 0 - Dump 25.6 Mbps PHY registers */
2555 if (left
-- < NS_TST_NUM_ENTRIES
) {
2556 if (card
->tste2vc
[left
+ 1] == NULL
)
2557 return sprintf(page
, "%5d - VBR/UBR \n", left
+ 1);
2559 return sprintf(page
, "%5d - %d %d \n", left
+ 1,
2560 card
->tste2vc
[left
+ 1]->tx_vcc
->vpi
,
2561 card
->tste2vc
[left
+ 1]->tx_vcc
->vci
);
2567 static int ns_ioctl(struct atm_dev
*dev
, unsigned int cmd
, void __user
* arg
)
2572 unsigned long flags
;
2574 card
= dev
->dev_data
;
2578 (pl
.buftype
, &((pool_levels __user
*) arg
)->buftype
))
2580 switch (pl
.buftype
) {
2581 case NS_BUFTYPE_SMALL
:
2583 ns_stat_sfbqc_get(readl(card
->membase
+ STAT
));
2584 pl
.level
.min
= card
->sbnr
.min
;
2585 pl
.level
.init
= card
->sbnr
.init
;
2586 pl
.level
.max
= card
->sbnr
.max
;
2589 case NS_BUFTYPE_LARGE
:
2591 ns_stat_lfbqc_get(readl(card
->membase
+ STAT
));
2592 pl
.level
.min
= card
->lbnr
.min
;
2593 pl
.level
.init
= card
->lbnr
.init
;
2594 pl
.level
.max
= card
->lbnr
.max
;
2597 case NS_BUFTYPE_HUGE
:
2598 pl
.count
= card
->hbpool
.count
;
2599 pl
.level
.min
= card
->hbnr
.min
;
2600 pl
.level
.init
= card
->hbnr
.init
;
2601 pl
.level
.max
= card
->hbnr
.max
;
2604 case NS_BUFTYPE_IOVEC
:
2605 pl
.count
= card
->iovpool
.count
;
2606 pl
.level
.min
= card
->iovnr
.min
;
2607 pl
.level
.init
= card
->iovnr
.init
;
2608 pl
.level
.max
= card
->iovnr
.max
;
2612 return -ENOIOCTLCMD
;
2615 if (!copy_to_user((pool_levels __user
*) arg
, &pl
, sizeof(pl
)))
2616 return (sizeof(pl
));
2621 if (!capable(CAP_NET_ADMIN
))
2623 if (copy_from_user(&pl
, (pool_levels __user
*) arg
, sizeof(pl
)))
2625 if (pl
.level
.min
>= pl
.level
.init
2626 || pl
.level
.init
>= pl
.level
.max
)
2628 if (pl
.level
.min
== 0)
2630 switch (pl
.buftype
) {
2631 case NS_BUFTYPE_SMALL
:
2632 if (pl
.level
.max
> TOP_SB
)
2634 card
->sbnr
.min
= pl
.level
.min
;
2635 card
->sbnr
.init
= pl
.level
.init
;
2636 card
->sbnr
.max
= pl
.level
.max
;
2639 case NS_BUFTYPE_LARGE
:
2640 if (pl
.level
.max
> TOP_LB
)
2642 card
->lbnr
.min
= pl
.level
.min
;
2643 card
->lbnr
.init
= pl
.level
.init
;
2644 card
->lbnr
.max
= pl
.level
.max
;
2647 case NS_BUFTYPE_HUGE
:
2648 if (pl
.level
.max
> TOP_HB
)
2650 card
->hbnr
.min
= pl
.level
.min
;
2651 card
->hbnr
.init
= pl
.level
.init
;
2652 card
->hbnr
.max
= pl
.level
.max
;
2655 case NS_BUFTYPE_IOVEC
:
2656 if (pl
.level
.max
> TOP_IOVB
)
2658 card
->iovnr
.min
= pl
.level
.min
;
2659 card
->iovnr
.init
= pl
.level
.init
;
2660 card
->iovnr
.max
= pl
.level
.max
;
2670 if (!capable(CAP_NET_ADMIN
))
2672 btype
= (long)arg
; /* a long is the same size as a pointer or bigger */
2674 case NS_BUFTYPE_SMALL
:
2675 while (card
->sbfqc
< card
->sbnr
.init
) {
2678 sb
= __dev_alloc_skb(NS_SMSKBSIZE
, GFP_KERNEL
);
2681 NS_PRV_BUFTYPE(sb
) = BUF_SM
;
2682 skb_queue_tail(&card
->sbpool
.queue
, sb
);
2683 skb_reserve(sb
, NS_AAL0_HEADER
);
2684 push_rxbufs(card
, sb
);
2688 case NS_BUFTYPE_LARGE
:
2689 while (card
->lbfqc
< card
->lbnr
.init
) {
2692 lb
= __dev_alloc_skb(NS_LGSKBSIZE
, GFP_KERNEL
);
2695 NS_PRV_BUFTYPE(lb
) = BUF_LG
;
2696 skb_queue_tail(&card
->lbpool
.queue
, lb
);
2697 skb_reserve(lb
, NS_SMBUFSIZE
);
2698 push_rxbufs(card
, lb
);
2702 case NS_BUFTYPE_HUGE
:
2703 while (card
->hbpool
.count
> card
->hbnr
.init
) {
2706 spin_lock_irqsave(&card
->int_lock
, flags
);
2707 hb
= skb_dequeue(&card
->hbpool
.queue
);
2708 card
->hbpool
.count
--;
2709 spin_unlock_irqrestore(&card
->int_lock
, flags
);
2712 ("nicstar%d: huge buffer count inconsistent.\n",
2715 dev_kfree_skb_any(hb
);
2718 while (card
->hbpool
.count
< card
->hbnr
.init
) {
2721 hb
= __dev_alloc_skb(NS_HBUFSIZE
, GFP_KERNEL
);
2724 NS_PRV_BUFTYPE(hb
) = BUF_NONE
;
2725 spin_lock_irqsave(&card
->int_lock
, flags
);
2726 skb_queue_tail(&card
->hbpool
.queue
, hb
);
2727 card
->hbpool
.count
++;
2728 spin_unlock_irqrestore(&card
->int_lock
, flags
);
2732 case NS_BUFTYPE_IOVEC
:
2733 while (card
->iovpool
.count
> card
->iovnr
.init
) {
2734 struct sk_buff
*iovb
;
2736 spin_lock_irqsave(&card
->int_lock
, flags
);
2737 iovb
= skb_dequeue(&card
->iovpool
.queue
);
2738 card
->iovpool
.count
--;
2739 spin_unlock_irqrestore(&card
->int_lock
, flags
);
2742 ("nicstar%d: iovec buffer count inconsistent.\n",
2745 dev_kfree_skb_any(iovb
);
2748 while (card
->iovpool
.count
< card
->iovnr
.init
) {
2749 struct sk_buff
*iovb
;
2751 iovb
= alloc_skb(NS_IOVBUFSIZE
, GFP_KERNEL
);
2754 NS_PRV_BUFTYPE(iovb
) = BUF_NONE
;
2755 spin_lock_irqsave(&card
->int_lock
, flags
);
2756 skb_queue_tail(&card
->iovpool
.queue
, iovb
);
2757 card
->iovpool
.count
++;
2758 spin_unlock_irqrestore(&card
->int_lock
, flags
);
2769 if (dev
->phy
&& dev
->phy
->ioctl
) {
2770 return dev
->phy
->ioctl(dev
, cmd
, arg
);
2772 printk("nicstar%d: %s == NULL \n", card
->index
,
2773 dev
->phy
? "dev->phy->ioctl" : "dev->phy");
2774 return -ENOIOCTLCMD
;
2780 static void which_list(ns_dev
* card
, struct sk_buff
*skb
)
2782 printk("skb buf_type: 0x%08x\n", NS_PRV_BUFTYPE(skb
));
2784 #endif /* EXTRA_DEBUG */
2786 static void ns_poll(unsigned long arg
)
2790 unsigned long flags
;
2793 PRINTK("nicstar: Entering ns_poll().\n");
2794 for (i
= 0; i
< num_cards
; i
++) {
2796 if (spin_is_locked(&card
->int_lock
)) {
2797 /* Probably it isn't worth spinning */
2800 spin_lock_irqsave(&card
->int_lock
, flags
);
2803 stat_r
= readl(card
->membase
+ STAT
);
2804 if (stat_r
& NS_STAT_TSIF
)
2805 stat_w
|= NS_STAT_TSIF
;
2806 if (stat_r
& NS_STAT_EOPDU
)
2807 stat_w
|= NS_STAT_EOPDU
;
2812 writel(stat_w
, card
->membase
+ STAT
);
2813 spin_unlock_irqrestore(&card
->int_lock
, flags
);
2815 mod_timer(&ns_timer
, jiffies
+ NS_POLL_PERIOD
);
2816 PRINTK("nicstar: Leaving ns_poll().\n");
2819 static int ns_parse_mac(char *mac
, unsigned char *esi
)
2824 if (mac
== NULL
|| esi
== NULL
)
2827 for (i
= 0; i
< 6; i
++) {
2828 if ((byte1
= ns_h2i(mac
[j
++])) < 0)
2830 if ((byte0
= ns_h2i(mac
[j
++])) < 0)
2832 esi
[i
] = (unsigned char)(byte1
* 16 + byte0
);
2834 if (mac
[j
++] != ':')
2841 static short ns_h2i(char c
)
2843 if (c
>= '0' && c
<= '9')
2844 return (short)(c
- '0');
2845 if (c
>= 'A' && c
<= 'F')
2846 return (short)(c
- 'A' + 10);
2847 if (c
>= 'a' && c
<= 'f')
2848 return (short)(c
- 'a' + 10);
2852 static void ns_phy_put(struct atm_dev
*dev
, unsigned char value
,
2856 unsigned long flags
;
2858 card
= dev
->dev_data
;
2859 spin_lock_irqsave(&card
->res_lock
, flags
);
2860 while (CMD_BUSY(card
)) ;
2861 writel((u32
) value
, card
->membase
+ DR0
);
2862 writel(NS_CMD_WRITE_UTILITY
| 0x00000200 | (addr
& 0x000000FF),
2863 card
->membase
+ CMD
);
2864 spin_unlock_irqrestore(&card
->res_lock
, flags
);
2867 static unsigned char ns_phy_get(struct atm_dev
*dev
, unsigned long addr
)
2870 unsigned long flags
;
2873 card
= dev
->dev_data
;
2874 spin_lock_irqsave(&card
->res_lock
, flags
);
2875 while (CMD_BUSY(card
)) ;
2876 writel(NS_CMD_READ_UTILITY
| 0x00000200 | (addr
& 0x000000FF),
2877 card
->membase
+ CMD
);
2878 while (CMD_BUSY(card
)) ;
2879 data
= readl(card
->membase
+ DR0
) & 0x000000FF;
2880 spin_unlock_irqrestore(&card
->res_lock
, flags
);
2881 return (unsigned char)data
;
2884 module_init(nicstar_init
);
2885 module_exit(nicstar_cleanup
);