35 #include <linux/module.h>
36 #include <linux/kernel.h>
38 #include <linux/atmdev.h>
39 #include <linux/atm.h>
40 #include <linux/pci.h>
42 #include <linux/types.h>
43 #include <linux/string.h>
46 #include <linux/sched.h>
49 #include <linux/bitops.h>
50 #include <linux/slab.h>
53 #include <asm/uaccess.h>
56 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
59 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
75 #undef NS_USE_DESTRUCTORS
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...)
99 #define XPRINTK(args...) printk(args)
101 #define XPRINTK(args...)
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))
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);
151 static int ns_ioctl(
struct atm_dev *
dev,
unsigned int cmd,
void __user *
arg);
155 static void ns_poll(
unsigned long arg);
156 static int ns_parse_mac(
char *
mac,
unsigned char *esi);
159 static unsigned char ns_phy_get(
struct atm_dev *
dev,
unsigned long addr);
164 static unsigned num_cards;
170 .phy_put = ns_phy_put,
171 .phy_get = ns_phy_get,
172 .proc_read = ns_proc_read,
186 static int index = -1;
192 error = ns_init_card(index, pcidev);
194 cards[index--] =
NULL;
214 if (cards[i] ==
NULL)
236 PRINTK(
"nicstar%d: %d huge buffers freed.\n", i, j);
238 PRINTK(
"nicstar%d: freeing %d iovec buffers.\n", i,
244 PRINTK(
"nicstar%d: %d iovec buffers freed.\n", i, j);
274 .id_table = nicstar_pci_tbl,
275 .probe = nicstar_init_one,
279 static int __init nicstar_init(
void)
283 XPRINTK(
"nicstar: nicstar_init() called.\n");
285 error = pci_register_driver(&nicstar_driver);
287 TXPRINTK(
"nicstar: TX debug enabled.\n");
288 RXPRINTK(
"nicstar: RX debug enabled.\n");
289 PRINTK(
"nicstar: General debug enabled.\n");
291 printk(
"nicstar: using PHY loopback.\n");
293 XPRINTK(
"nicstar: nicstar_init() returned.\n");
299 ns_timer.function = ns_poll;
306 static void __exit nicstar_cleanup(
void)
308 XPRINTK(
"nicstar: nicstar_cleanup() called.\n");
314 XPRINTK(
"nicstar: nicstar_cleanup() returned.\n");
317 static u32 ns_read_sram(
ns_dev * card,
u32 sram_address)
322 sram_address &= 0x0007FFFC;
323 sram_address |= 0x50000000;
329 spin_unlock_irqrestore(&card->
res_lock, flags);
343 for (i = 0; i <=
c; i += 4)
348 sram_address &= 0x0007FFFC;
349 sram_address |= (0x40000000 |
count);
351 spin_unlock_irqrestore(&card->
res_lock, flags);
358 unsigned char pci_latency;
369 printk(
"nicstar%d: can't enable PCI device\n", i);
371 ns_init_card_error(card, error);
374 if ((pci_set_dma_mask(pcidev,
DMA_BIT_MASK(32)) != 0) ||
375 (pci_set_consistent_dma_mask(pcidev,
DMA_BIT_MASK(32)) != 0)) {
377 "nicstar%d: No suitable DMA available.\n", i);
379 ns_init_card_error(card, error);
385 (
"nicstar%d: can't allocate memory for device structure.\n",
388 ns_init_card_error(card, error);
395 pci_set_drvdata(pcidev, card);
403 printk(
"nicstar%d: can't ioremap() membase.\n", i);
405 ns_init_card_error(card, error);
413 printk(
"nicstar%d: can't read PCI latency timer.\n", i);
415 ns_init_card_error(card, error);
418 #ifdef NS_PCI_LATENCY
419 if (pci_latency < NS_PCI_LATENCY) {
420 PRINTK(
"nicstar%d: setting PCI latency timer to %d.\n", i,
422 for (j = 1; j < 4; j++) {
423 if (pci_write_config_byte
429 (
"nicstar%d: can't set PCI latency timer to %d.\n",
432 ns_init_card_error(card, error);
464 printk(
"nicstar%d: PHY seems to be 25 Mbps.\n", i);
479 printk(
"nicstar%d: PHY seems to be 155 Mbps.\n", i);
488 printk(
"nicstar%d: unknown PHY type (0x%08X).\n", i, data);
490 ns_init_card_error(card, error);
497 ns_write_sram(card, 0x1C003, &data, 1);
499 ns_write_sram(card, 0x14003, &data, 1);
500 if (ns_read_sram(card, 0x14003) == 0x89ABCDEF &&
501 ns_read_sram(card, 0x1C003) == 0x76543210)
509 #if (NS_MAX_RCTSIZE == 4096)
512 (
"nicstar%d: limiting maximum VCI. See NS_MAX_RCTSIZE in nicstar.h\n",
514 #elif (NS_MAX_RCTSIZE == 16384)
517 (
"nicstar%d: wasting memory. See NS_MAX_RCTSIZE in nicstar.h\n",
522 #error NS_MAX_RCTSIZE must be either 4096 or 16384 in nicstar.c
533 nicstar_init_eprom(card->
membase);
543 printk(
"nicstar%d: can't allocate TSQ.\n", i);
545 ns_init_card_error(card, error);
562 printk(
"nicstar%d: can't allocate RSQ.\n", i);
564 ns_init_card_error(card, error);
581 printk(
"nicstar%d: can't get SCQ0.\n", i);
583 ns_init_card_error(card, error);
587 u32d[1] = (
u32) 0x00000000;
588 u32d[2] = (
u32) 0xffffffff;
589 u32d[3] = (
u32) 0x00000000;
594 PRINTK(
"nicstar%d: VBR-SCQ0 base at 0x%p.\n", i, card->
scq0->
base);
601 ns_write_sram(card,
NS_TST0 + j, &data, 1);
603 ns_write_sram(card,
NS_TST0 + NS_TST_NUM_ENTRIES, &data, 1);
605 ns_write_sram(card,
NS_TST1 + j, &data, 1);
607 ns_write_sram(card,
NS_TST1 + NS_TST_NUM_ENTRIES, &data, 1);
616 u32d[0] = 0x00000000;
618 u32d[1] = 0x00000000;
619 u32d[2] = 0x00000000;
620 u32d[3] = 0xFFFFFFFF;
621 for (j = 0; j < card->
rct_size; j++)
622 ns_write_sram(card, j * 4, u32d, 4);
655 for (j = 0; j <
NUM_HB; j++) {
660 (
"nicstar%d: can't allocate %dth of %d huge buffers.\n",
663 ns_init_card_error(card, error);
674 for (j = 0; j <
NUM_LB; j++) {
679 (
"nicstar%d: can't allocate %dth of %d large buffers.\n",
682 ns_init_card_error(card, error);
688 push_rxbufs(card, lb);
700 (
"nicstar%d: Strange... Just allocated %d large buffers and lfbqc = %d.\n",
703 ns_init_card_error(card, error);
710 for (j = 0; j <
NUM_SB; j++) {
715 (
"nicstar%d: can't allocate %dth of %d small buffers.\n",
718 ns_init_card_error(card, error);
724 push_rxbufs(card, sb);
730 (
"nicstar%d: Strange... Just allocated %d small buffers and sfbqc = %d.\n",
733 ns_init_card_error(card, error);
745 (
"nicstar%d: can't allocate %dth of %d iovec buffers.\n",
748 ns_init_card_error(card, error);
766 (pcidev->
irq, &ns_irq_handler,
IRQF_SHARED,
"nicstar", card) != 0) {
767 printk(
"nicstar%d: can't allocate IRQ %d.\n", i, pcidev->
irq);
769 ns_init_card_error(card, error);
777 printk(
"nicstar%d: can't register device.\n", i);
779 ns_init_card_error(card, error);
783 if (ns_parse_mac(
mac[i], card->
atmdev->esi)) {
786 if (
memcmp(card->
atmdev->esi,
"\x00\x00\x00\x00\x00\x00", 6) ==
788 nicstar_read_eprom(card->
membase,
794 printk(
"nicstar%d: MAC address %pM\n", i, card->
atmdev->esi);
802 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
807 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
919 vcc->
pop(vcc, scq->
skb[i]);
927 (
"nicstar: free_scq() called with vcc == NULL for fixed rate scq.");
934 vcc->
pop(vcc, scq->
skb[i]);
952 struct sk_buff *handle1, *handle2;
963 addr1 = pci_map_single(card->
pcidev,
972 printk(
"nicstar%d: push_rxbufs called with addr1 = 0.\n",
1033 "nicstar%d: no free memory for idr\n",
1041 if (!
id2 && err == 0)
1044 }
while (err == -
EAGAIN);
1057 spin_unlock_irqrestore(&card->
res_lock, flags);
1059 XPRINTK(
"nicstar%d: Pushing %s buffers at 0x%x and 0x%x.\n",
1081 unsigned long flags;
1083 card = (
ns_dev *) dev_id;
1087 PRINTK(
"nicstar%d: NICStAR generated an interrupt\n", card->
index);
1103 TXPRINTK(
"nicstar%d: Incomplete CS-PDU transmitted.\n",
1115 if (stat_r & NS_STAT_TMROF) {
1117 PRINTK(
"nicstar%d: Timer overflow.\n", card->
index);
1123 PRINTK(
"nicstar%d: PHY interrupt.\n", card->
index);
1124 if (dev->
phy && dev->
phy->interrupt) {
1125 dev->
phy->interrupt(dev);
1132 printk(
"nicstar%d: Small free buffer queue is full.\n",
1139 printk(
"nicstar%d: Large free buffer queue is full.\n",
1152 RXPRINTK(
"nicstar%d: End of CS-PDU received.\n", card->
index);
1161 printk(
"nicstar%d: Raw cell received and no support yet...\n",
1172 oldbuf = card->
rcbuf;
1178 recycle_rx_buf(card, oldbuf);
1192 printk(
"nicstar%d: Small free buffer queue empty.\n",
1194 for (i = 0; i < card->
sbnr.
min; i++) {
1205 push_rxbufs(card, sb);
1217 printk(
"nicstar%d: Large free buffer queue empty.\n",
1219 for (i = 0; i < card->
lbnr.
min; i++) {
1230 push_rxbufs(card, lb);
1243 spin_unlock_irqrestore(&card->
int_lock, flags);
1244 PRINTK(
"nicstar%d: end of interrupt service\n", card->
index);
1248 static int ns_open(
struct atm_vcc *vcc)
1252 unsigned long tmpl, modl;
1262 short vpi = vcc->
vpi;
1266 PRINTK(
"nicstar%d: opening vpi.vci %d.%d \n", card->
index, (
int)vpi,
1269 PRINTK(
"nicstar%d: unsupported AAL.\n", card->
index);
1282 printk(
"nicstar%d: %s vci already in use.\n", card->
index,
1283 inuse == 1 ?
"tx" : inuse == 2 ?
"rx" :
"tx and rx");
1296 if (vcc->
qos.txtp.traffic_class ==
ATM_CBR) {
1298 if (vcc->
qos.txtp.max_pcr == 0 && vcc->
qos.txtp.pcr == 0
1299 && vcc->
qos.txtp.min_pcr == 0) {
1301 (
"nicstar%d: trying to open a CBR vc with cell rate = 0 \n",
1309 tcra = tcr >= 0 ? tcr : -
tcr;
1311 PRINTK(
"nicstar%d: target cell rate = %d.\n",
1312 card->
index, vcc->
qos.txtp.max_pcr);
1315 (
unsigned long)tcra *(
unsigned long)
1323 }
else if (tcr == 0) {
1328 (
"nicstar%d: no CBR bandwidth free.\n",
1338 (
"nicstar%d: selected bandwidth < granularity.\n",
1347 (
"nicstar%d: not enough free CBR bandwidth.\n",
1355 XPRINTK(
"nicstar%d: writing %d tst entries.\n",
1359 card->
scd2vc[frscdi] = vc;
1363 if (frscdi == NS_FRSCD_NUM) {
1365 (
"nicstar%d: no SCD available for CBR channel.\n",
1377 PRINTK(
"nicstar%d: can't get fixed rate SCQ.\n",
1387 u32d[1] = (
u32) 0x00000000;
1388 u32d[2] = (
u32) 0xffffffff;
1389 u32d[3] = (
u32) 0x00000000;
1390 ns_write_sram(card, vc->
cbr_scd, u32d, 4);
1392 fill_tst(card, n, vc);
1393 }
else if (vcc->
qos.txtp.traffic_class ==
ATM_UBR) {
1420 (vpi << card->
vcibits | vci) *
1430 static void ns_close(
struct atm_vcc *vcc)
1438 card = vcc->
dev->dev_data;
1439 PRINTK(
"nicstar%d: closing vpi.vci %d.%d \n", card->
index,
1440 (
int)vcc->
vpi, vcc->
vci);
1446 unsigned long flags;
1455 spin_unlock_irqrestore(&card->
res_lock, flags);
1467 (
"nicstar%d: closing a VC with pending rx buffers.\n",
1470 recycle_iovec_rx_bufs(card, (
struct iovec *)iovb->
data,
1474 recycle_iov_buf(card, iovb);
1475 spin_unlock_irqrestore(&card->
int_lock, flags);
1484 if (vcc->
qos.txtp.traffic_class ==
ATM_CBR) {
1485 unsigned long flags;
1494 if (scqep == scq->
base)
1498 if (scqep == scq->
tail) {
1499 spin_unlock_irqrestore(&scq->
lock, flags);
1524 ns_write_sram(card, scq->
scd, &data, 1);
1526 spin_unlock_irqrestore(&scq->
lock, flags);
1534 ns_write_sram(card, card->
tst_addr + i, &data,
1542 free_scq(card, vc->
scq, vcc);
1547 unsigned long flags;
1555 atm_return(vcc, scq->
skb[i]->truesize);
1557 (
"nicstar: deleted pending vcc mapping\n");
1561 spin_unlock_irqrestore(&scq->
lock, flags);
1573 printk(
"STAT = 0x%08X CFG = 0x%08X \n", stat, cfg);
1575 (
"TSQ: base = 0x%p next = 0x%p last = 0x%p TSQT = 0x%08X \n",
1579 (
"RSQ: base = 0x%p next = 0x%p last = 0x%p RSQT = 0x%08X \n",
1582 printk(
"Empty free buffer queue interrupt %s \n",
1583 card->
efbie ?
"enabled" :
"disabled");
1584 printk(
"SBCNT = %d count = %d LBCNT = %d count = %d \n",
1587 printk(
"hbpool.count = %d iovpool.count = %d \n",
1593 static void fill_tst(
ns_dev * card,
int n,
vc_map * vc)
1612 if (e == NS_TST_NUM_ENTRIES) {
1613 printk(
"nicstar%d: No free TST entries found. \n", card->
index);
1622 if (cl >= NS_TST_NUM_ENTRIES && card->
tste2vc[e] ==
NULL) {
1624 ns_write_sram(card, new_tst + e, &data, 1);
1629 if (++e == NS_TST_NUM_ENTRIES) {
1638 ns_write_sram(card, new_tst + NS_TST_NUM_ENTRIES, &data, 1);
1639 ns_write_sram(card, card->
tst_addr + NS_TST_NUM_ENTRIES, &data, 1);
1652 card = vcc->
dev->dev_data;
1655 printk(
"nicstar%d: vcc->dev_data == NULL on ns_send().\n",
1663 printk(
"nicstar%d: Trying to transmit on a non-tx VC.\n",
1671 printk(
"nicstar%d: Only AAL0 and AAL5 are supported.\n",
1678 if (skb_shinfo(skb)->nr_frags != 0) {
1679 printk(
"nicstar%d: No scatter-gather yet.\n", card->
index);
1691 buflen = (skb->
len + 47 + 8) / 48 * 48;
1706 if (*skb->
data & 0x02)
1718 if (vcc->
qos.txtp.traffic_class ==
ATM_CBR) {
1727 if (push_scqe(card, vc, scq, &scqe, skb) != 0) {
1740 unsigned long flags;
1750 spin_unlock_irqrestore(&scq->
lock, flags);
1751 printk(
"nicstar%d: Error pushing TBD.\n", card->
index);
1756 spin_unlock_irqrestore(&scq->
lock, flags);
1762 spin_unlock_irqrestore(&scq->
lock, flags);
1763 printk(
"nicstar%d: Timeout pushing TBD.\n",
1771 XPRINTK(
"nicstar%d: sending skb at 0x%p (pos %d).\n",
1772 card->
index, skb, index);
1773 XPRINTK(
"nicstar%d: TBD written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%p.\n",
1796 ns_write_sram(card, scq->
scd, &data, 1);
1797 spin_unlock_irqrestore(&scq->
lock, flags);
1798 printk(
"nicstar%d: Error pushing TSR.\n",
1806 spin_unlock_irqrestore(&scq->
lock, flags);
1827 (
"nicstar%d: TSR written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%p.\n",
1838 PRINTK(
"nicstar%d: Timeout pushing TSR.\n",
1842 ns_write_sram(card, scq->
scd, &data, 1);
1844 spin_unlock_irqrestore(&scq->
lock, flags);
1849 static void process_tsq(
ns_dev * card)
1853 ns_tsi *previous =
NULL, *one_ahead, *two_ahead;
1854 int serviced_entries;
1856 serviced_entries = 0;
1861 one_ahead = card->
tsq.
next + 1;
1863 if (one_ahead == card->
tsq.
last)
1866 two_ahead = one_ahead + 1;
1872 serviced_entries = 1;
1889 (
"nicstar%d: could not find VC from SCD index.\n",
1911 one_ahead = card->
tsq.
next + 1;
1913 if (one_ahead == card->
tsq.
last)
1916 two_ahead = one_ahead + 1;
1919 if (serviced_entries)
1929 unsigned long flags;
1931 XPRINTK(
"nicstar%d: drain_scq() called, scq at 0x%p, pos %d.\n",
1932 card->
index, scq, pos);
1934 printk(
"nicstar%d: Bad index on drain_scq().\n", card->
index);
1944 XPRINTK(
"nicstar%d: freeing skb at 0x%p (index %d).\n",
1945 card->
index, skb, i);
1947 pci_unmap_single(card->
pcidev,
1952 if (vcc && vcc->
pop !=
NULL) {
1963 spin_unlock_irqrestore(&scq->
lock, flags);
1966 static void process_rsq(
ns_dev * card)
1973 dequeue_rx(card, card->
rsq.
next);
1992 unsigned short aal5_len;
2005 "nicstar%d: idr_find() failed!\n", card->
index);
2009 pci_dma_sync_single_for_cpu(card->
pcidev,
2014 pci_unmap_single(card->
pcidev,
2022 printk(
"nicstar%d: SDU received for out-of-range vc %d.%d.\n",
2023 card->
index, vpi, vci);
2024 recycle_rx_buf(card, skb);
2030 RXPRINTK(
"nicstar%d: SDU received on non-rx vc %d.%d.\n",
2031 card->
index, vpi, vci);
2032 recycle_rx_buf(card, skb);
2040 unsigned char *cell;
2047 (
"nicstar%d: Can't allocate buffers for aal0.\n",
2054 (
"nicstar%d: atm_charge() dropped aal0 packets.\n",
2064 *((
u32 *) sb->
data) |= 0x00000002;
2069 __net_timestamp(sb);
2075 recycle_rx_buf(card, skb);
2086 printk(
"nicstar%d: Out of iovec buffers.\n",
2089 recycle_rx_buf(card, skb);
2106 skb_reset_tail_pointer(iovb);
2111 printk(
"nicstar%d: received too big AAL5 SDU.\n", card->
index);
2113 recycle_iovec_rx_bufs(card, (
struct iovec *)iovb->
data,
2118 skb_reset_tail_pointer(iovb);
2129 (
"nicstar%d: Expected a small buffer, and this is not one.\n",
2131 which_list(card, skb);
2133 recycle_rx_buf(card, skb);
2135 recycle_iov_buf(card, iovb);
2142 (
"nicstar%d: Expected a large buffer, and this is not one.\n",
2144 which_list(card, skb);
2146 recycle_iovec_rx_bufs(card, (
struct iovec *)iovb->
data,
2149 recycle_iov_buf(card, iovb);
2157 unsigned char *L1L2 = (
unsigned char *)
2159 aal5_len = L1L2[0] << 8 | L1L2[1];
2160 len = (aal5_len == 0x0000) ? 0x10000 : aal5_len;
2162 len + 8 > iovb->
len || len + (47 + 8) < iovb->
len) {
2164 if (len + 8 > iovb->
len || len + (47 + 8) < iovb->
len)
2165 printk(
" - PDU size mismatch.\n");
2169 recycle_iovec_rx_bufs(card, (
struct iovec *)iovb->
data,
2172 recycle_iov_buf(card, iovb);
2181 push_rxbufs(card, skb);
2185 dequeue_sm_buf(card, skb);
2186 #ifdef NS_USE_DESTRUCTORS
2190 __net_timestamp(skb);
2191 vcc->
push(vcc, skb);
2197 sb = (
struct sk_buff *)(iov - 1)->iov_base;
2202 push_rxbufs(card, sb);
2206 dequeue_sm_buf(card, sb);
2207 #ifdef NS_USE_DESTRUCTORS
2211 __net_timestamp(sb);
2216 push_rxbufs(card, skb);
2221 push_rxbufs(card, skb);
2224 dequeue_lg_buf(card, skb);
2225 #ifdef NS_USE_DESTRUCTORS
2229 skb_copy_from_linear_data(sb, skb->
data,
2233 __net_timestamp(skb);
2234 vcc->
push(vcc, skb);
2238 push_rxbufs(card, sb);
2245 int remaining, tocopy;
2254 (
"nicstar%d: Out of huge buffers.\n",
2257 recycle_iovec_rx_bufs(card,
2262 recycle_iov_buf(card, iovb);
2300 recycle_iovec_rx_bufs(card, iov,
2311 skb_copy_from_linear_data(sb, hb->
data,
2314 remaining = len - iov->
iov_len;
2317 push_rxbufs(card, sb);
2324 skb_copy_from_linear_data(lb,
2329 remaining -= tocopy;
2330 push_rxbufs(card, lb);
2333 if (remaining != 0 || hb->
len != len)
2335 (
"nicstar%d: Huge buffer len mismatch.\n",
2339 #ifdef NS_USE_DESTRUCTORS
2342 __net_timestamp(hb);
2349 recycle_iov_buf(card, iovb);
2354 #ifdef NS_USE_DESTRUCTORS
2356 static void ns_sb_destructor(
struct sk_buff *sb)
2373 push_rxbufs(card, sb);
2377 static void ns_lb_destructor(
struct sk_buff *lb)
2394 push_rxbufs(card, lb);
2398 static void ns_hb_destructor(
struct sk_buff *hb)
2416 static void recycle_rx_buf(
ns_dev * card,
struct sk_buff *skb)
2419 printk(
"nicstar%d: What kind of rx buffer is this?\n",
2423 push_rxbufs(card, skb);
2426 static void recycle_iovec_rx_bufs(
ns_dev * card,
struct iovec *iov,
int count)
2429 recycle_rx_buf(card, (
struct sk_buff *)(iov++)->iov_base);
2432 static void recycle_iov_buf(
ns_dev * card,
struct sk_buff *iovb)
2441 static void dequeue_sm_buf(
ns_dev * card,
struct sk_buff *sb)
2444 #ifdef NS_USE_DESTRUCTORS
2453 push_rxbufs(card, new_sb);
2464 push_rxbufs(card, new_sb);
2469 static void dequeue_lg_buf(
ns_dev * card,
struct sk_buff *lb)
2472 #ifdef NS_USE_DESTRUCTORS
2481 push_rxbufs(card, new_lb);
2492 push_rxbufs(card, new_lb);
2497 static int ns_proc_read(
struct atm_dev *dev, loff_t * pos,
char *
page)
2507 return sprintf(page,
"Pool count min init max \n");
2509 return sprintf(page,
"Small %5d %5d %5d %5d \n",
2513 return sprintf(page,
"Large %5d %5d %5d %5d \n",
2517 return sprintf(page,
"Huge %5d %5d %5d %5d \n",
2521 return sprintf(page,
"Iovec %5d %5d %5d %5d \n",
2539 for (i = 0; i < 4; i++) {
2547 return sprintf(page,
"PHY regs: 0x%02X 0x%02X 0x%02X 0x%02X \n",
2548 phy_regs[0], phy_regs[1], phy_regs[2],
2554 if (left-- < NS_TST_NUM_ENTRIES) {
2556 return sprintf(page,
"%5d - VBR/UBR \n", left + 1);
2558 return sprintf(page,
"%5d - %d %d \n", left + 1,
2566 static int ns_ioctl(
struct atm_dev *dev,
unsigned int cmd,
void __user *
arg)
2571 unsigned long flags;
2615 return (
sizeof(pl));
2683 push_rxbufs(card, sb);
2697 push_rxbufs(card, lb);
2708 spin_unlock_irqrestore(&card->
int_lock, flags);
2711 (
"nicstar%d: huge buffer count inconsistent.\n",
2727 spin_unlock_irqrestore(&card->
int_lock, flags);
2738 spin_unlock_irqrestore(&card->
int_lock, flags);
2741 (
"nicstar%d: iovec buffer count inconsistent.\n",
2757 spin_unlock_irqrestore(&card->
int_lock, flags);
2768 if (dev->
phy && dev->
phy->ioctl) {
2769 return dev->
phy->ioctl(dev, cmd, arg);
2772 dev->
phy ?
"dev->phy->ioctl" :
"dev->phy");
2785 static void ns_poll(
unsigned long arg)
2789 unsigned long flags;
2792 PRINTK(
"nicstar: Entering ns_poll().\n");
2793 for (i = 0; i < num_cards; i++) {
2795 if (spin_is_locked(&card->
int_lock)) {
2803 if (stat_r & NS_STAT_TSIF)
2805 if (stat_r & NS_STAT_EOPDU)
2812 spin_unlock_irqrestore(&card->
int_lock, flags);
2815 PRINTK(
"nicstar: Leaving ns_poll().\n");
2818 static int ns_parse_mac(
char *
mac,
unsigned char *esi)
2826 for (i = 0; i < 6; i++) {
2831 esi[
i] = (
unsigned char)(byte1 * 16 + byte0);
2833 if (mac[j++] !=
':')
2841 static void ns_phy_put(
struct atm_dev *dev,
unsigned char value,
2845 unsigned long flags;
2853 spin_unlock_irqrestore(&card->
res_lock, flags);
2856 static unsigned char ns_phy_get(
struct atm_dev *dev,
unsigned long addr)
2859 unsigned long flags;
2869 spin_unlock_irqrestore(&card->
res_lock, flags);
2870 return (
unsigned char)
data;