1 /*******************************************************************
2 * ident "$Id: idt77252.c,v 1.2 2001/11/11 08:13:54 ecd Exp $"
5 * $Date: 2001/11/11 08:13:54 $
7 * Copyright (c) 2000 ATecoM GmbH
9 * The author may be reached at ecd@atecom.com.
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
19 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 * You should have received a copy of the GNU General Public License along
28 * with this program; if not, write to the Free Software Foundation, Inc.,
29 * 675 Mass Ave, Cambridge, MA 02139, USA.
31 *******************************************************************/
32 static char const rcsid
[] =
33 "$Id: idt77252.c,v 1.2 2001/11/11 08:13:54 ecd Exp $";
36 #include <linux/module.h>
37 #include <linux/config.h>
38 #include <linux/pci.h>
39 #include <linux/skbuff.h>
40 #include <linux/kernel.h>
41 #include <linux/vmalloc.h>
42 #include <linux/netdevice.h>
43 #include <linux/atmdev.h>
44 #include <linux/atm.h>
45 #include <linux/delay.h>
46 #include <linux/init.h>
47 #include <linux/bitops.h>
48 #include <linux/wait.h>
49 #include <asm/semaphore.h>
51 #include <asm/uaccess.h>
52 #include <asm/atomic.h>
53 #include <asm/byteorder.h>
55 #ifdef CONFIG_ATM_IDT77252_USE_SUNI
57 #endif /* CONFIG_ATM_IDT77252_USE_SUNI */
61 #include "idt77252_tables.h"
63 static unsigned int vpibits
= 1;
66 #define CONFIG_ATM_IDT77252_SEND_IDLE 1
72 #define DEBUG_MODULE 1
73 #undef HAVE_EEPROM /* does not work, yet. */
75 #ifdef CONFIG_ATM_IDT77252_DEBUG
76 static unsigned long debug
= DBG_GENERAL
;
80 #define SAR_RX_DELAY (SAR_CFG_RXINT_NODELAY)
86 static struct scq_info
*alloc_scq(struct idt77252_dev
*, int);
87 static void free_scq(struct idt77252_dev
*, struct scq_info
*);
88 static int queue_skb(struct idt77252_dev
*, struct vc_map
*,
89 struct sk_buff
*, int oam
);
90 static void drain_scq(struct idt77252_dev
*, struct vc_map
*);
91 static unsigned long get_free_scd(struct idt77252_dev
*, struct vc_map
*);
92 static void fill_scd(struct idt77252_dev
*, struct scq_info
*, int);
97 static int push_rx_skb(struct idt77252_dev
*,
98 struct sk_buff
*, int queue
);
99 static void recycle_rx_skb(struct idt77252_dev
*, struct sk_buff
*);
100 static void flush_rx_pool(struct idt77252_dev
*, struct rx_pool
*);
101 static void recycle_rx_pool_skb(struct idt77252_dev
*,
103 static void add_rx_skb(struct idt77252_dev
*, int queue
,
104 unsigned int size
, unsigned int count
);
109 static int init_rsq(struct idt77252_dev
*);
110 static void deinit_rsq(struct idt77252_dev
*);
111 static void idt77252_rx(struct idt77252_dev
*);
116 static int init_tsq(struct idt77252_dev
*);
117 static void deinit_tsq(struct idt77252_dev
*);
118 static void idt77252_tx(struct idt77252_dev
*);
124 static void idt77252_dev_close(struct atm_dev
*dev
);
125 static int idt77252_open(struct atm_vcc
*vcc
, short vpi
, int vci
);
126 static void idt77252_close(struct atm_vcc
*vcc
);
127 static int idt77252_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
128 static int idt77252_send_oam(struct atm_vcc
*vcc
, void *cell
,
130 static void idt77252_phy_put(struct atm_dev
*dev
, unsigned char value
,
132 static unsigned char idt77252_phy_get(struct atm_dev
*dev
, unsigned long addr
);
133 static int idt77252_change_qos(struct atm_vcc
*vcc
, struct atm_qos
*qos
,
135 static int idt77252_proc_read(struct atm_dev
*dev
, loff_t
* pos
,
137 static void idt77252_interrupt(int irq
, void *dev_id
,
138 struct pt_regs
*regs
);
139 static void idt77252_softint(void *dev_id
);
142 static struct atmdev_ops idt77252_ops
=
144 .dev_close
= idt77252_dev_close
,
145 .open
= idt77252_open
,
146 .close
= idt77252_close
,
147 .send
= idt77252_send
,
148 .send_oam
= idt77252_send_oam
,
149 .phy_put
= idt77252_phy_put
,
150 .phy_get
= idt77252_phy_get
,
151 .change_qos
= idt77252_change_qos
,
152 .proc_read
= idt77252_proc_read
155 static struct idt77252_dev
*idt77252_chain
= NULL
;
156 static unsigned int idt77252_sram_write_errors
= 0;
158 /*****************************************************************************/
160 /* I/O and Utility Bus */
162 /*****************************************************************************/
165 waitfor_idle(struct idt77252_dev
*card
)
169 stat
= readl(SAR_REG_STAT
);
170 while (stat
& SAR_STAT_CMDBZ
)
171 stat
= readl(SAR_REG_STAT
);
175 read_sram(struct idt77252_dev
*card
, unsigned long addr
)
180 spin_lock_irqsave(&card
->cmd_lock
, flags
);
181 writel(SAR_CMD_READ_SRAM
| (addr
<< 2), SAR_REG_CMD
);
183 value
= readl(SAR_REG_DR0
);
184 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
189 write_sram(struct idt77252_dev
*card
, unsigned long addr
, u32 value
)
193 if ((idt77252_sram_write_errors
== 0) &&
194 (((addr
> card
->tst
[0] + card
->tst_size
- 2) &&
195 (addr
< card
->tst
[0] + card
->tst_size
)) ||
196 ((addr
> card
->tst
[1] + card
->tst_size
- 2) &&
197 (addr
< card
->tst
[1] + card
->tst_size
)))) {
198 printk("%s: ERROR: TST JMP section at %08lx written: %08x\n",
199 card
->name
, addr
, value
);
202 spin_lock_irqsave(&card
->cmd_lock
, flags
);
203 writel(value
, SAR_REG_DR0
);
204 writel(SAR_CMD_WRITE_SRAM
| (addr
<< 2), SAR_REG_CMD
);
206 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
210 read_utility(void *dev
, unsigned long ubus_addr
)
212 struct idt77252_dev
*card
= dev
;
217 printk("Error: No such device.\n");
221 spin_lock_irqsave(&card
->cmd_lock
, flags
);
222 writel(SAR_CMD_READ_UTILITY
+ ubus_addr
, SAR_REG_CMD
);
224 value
= readl(SAR_REG_DR0
);
225 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
230 write_utility(void *dev
, unsigned long ubus_addr
, u8 value
)
232 struct idt77252_dev
*card
= dev
;
236 printk("Error: No such device.\n");
240 spin_lock_irqsave(&card
->cmd_lock
, flags
);
241 writel((u32
) value
, SAR_REG_DR0
);
242 writel(SAR_CMD_WRITE_UTILITY
+ ubus_addr
, SAR_REG_CMD
);
244 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
248 static u32 rdsrtab
[] =
250 SAR_GP_EECS
| SAR_GP_EESCLK
,
252 SAR_GP_EESCLK
, /* 0 */
254 SAR_GP_EESCLK
, /* 0 */
256 SAR_GP_EESCLK
, /* 0 */
258 SAR_GP_EESCLK
, /* 0 */
260 SAR_GP_EESCLK
, /* 0 */
262 SAR_GP_EESCLK
| SAR_GP_EEDO
, /* 1 */
264 SAR_GP_EESCLK
, /* 0 */
266 SAR_GP_EESCLK
| SAR_GP_EEDO
/* 1 */
269 static u32 wrentab
[] =
271 SAR_GP_EECS
| SAR_GP_EESCLK
,
273 SAR_GP_EESCLK
, /* 0 */
275 SAR_GP_EESCLK
, /* 0 */
277 SAR_GP_EESCLK
, /* 0 */
279 SAR_GP_EESCLK
, /* 0 */
281 SAR_GP_EESCLK
| SAR_GP_EEDO
, /* 1 */
283 SAR_GP_EESCLK
| SAR_GP_EEDO
, /* 1 */
285 SAR_GP_EESCLK
, /* 0 */
287 SAR_GP_EESCLK
/* 0 */
292 SAR_GP_EECS
| SAR_GP_EESCLK
,
294 SAR_GP_EESCLK
, /* 0 */
296 SAR_GP_EESCLK
, /* 0 */
298 SAR_GP_EESCLK
, /* 0 */
300 SAR_GP_EESCLK
, /* 0 */
302 SAR_GP_EESCLK
, /* 0 */
304 SAR_GP_EESCLK
, /* 0 */
306 SAR_GP_EESCLK
| SAR_GP_EEDO
, /* 1 */
308 SAR_GP_EESCLK
| SAR_GP_EEDO
/* 1 */
313 SAR_GP_EECS
| SAR_GP_EESCLK
,
315 SAR_GP_EESCLK
, /* 0 */
317 SAR_GP_EESCLK
, /* 0 */
319 SAR_GP_EESCLK
, /* 0 */
321 SAR_GP_EESCLK
, /* 0 */
323 SAR_GP_EESCLK
, /* 0 */
325 SAR_GP_EESCLK
, /* 0 */
327 SAR_GP_EESCLK
| SAR_GP_EEDO
, /* 1 */
329 SAR_GP_EESCLK
/* 0 */
332 static u32 clktab
[] =
354 idt77252_read_gp(struct idt77252_dev
*card
)
358 gp
= readl(SAR_REG_GP
);
360 printk("RD: %s\n", gp
& SAR_GP_EEDI
? "1" : "0");
366 idt77252_write_gp(struct idt77252_dev
*card
, u32 value
)
371 printk("WR: %s %s %s\n", value
& SAR_GP_EECS
? " " : "/CS",
372 value
& SAR_GP_EESCLK
? "HIGH" : "LOW ",
373 value
& SAR_GP_EEDO
? "1" : "0");
376 spin_lock_irqsave(&card
->cmd_lock
, flags
);
378 writel(value
, SAR_REG_GP
);
379 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
383 idt77252_eeprom_read_status(struct idt77252_dev
*card
)
389 gp
= idt77252_read_gp(card
) & ~(SAR_GP_EESCLK
|SAR_GP_EECS
|SAR_GP_EEDO
);
391 for (i
= 0; i
< sizeof(rdsrtab
)/sizeof(rdsrtab
[0]); i
++) {
392 idt77252_write_gp(card
, gp
| rdsrtab
[i
]);
395 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
399 for (i
= 0, j
= 0; i
< 8; i
++) {
402 idt77252_write_gp(card
, gp
| clktab
[j
++]);
405 byte
|= idt77252_read_gp(card
) & SAR_GP_EEDI
? 1 : 0;
407 idt77252_write_gp(card
, gp
| clktab
[j
++]);
410 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
417 idt77252_eeprom_read_byte(struct idt77252_dev
*card
, u8 offset
)
423 gp
= idt77252_read_gp(card
) & ~(SAR_GP_EESCLK
|SAR_GP_EECS
|SAR_GP_EEDO
);
425 for (i
= 0; i
< sizeof(rdtab
)/sizeof(rdtab
[0]); i
++) {
426 idt77252_write_gp(card
, gp
| rdtab
[i
]);
429 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
432 for (i
= 0, j
= 0; i
< 8; i
++) {
433 idt77252_write_gp(card
, gp
| clktab
[j
++] |
434 (offset
& 1 ? SAR_GP_EEDO
: 0));
437 idt77252_write_gp(card
, gp
| clktab
[j
++] |
438 (offset
& 1 ? SAR_GP_EEDO
: 0));
443 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
447 for (i
= 0, j
= 0; i
< 8; i
++) {
450 idt77252_write_gp(card
, gp
| clktab
[j
++]);
453 byte
|= idt77252_read_gp(card
) & SAR_GP_EEDI
? 1 : 0;
455 idt77252_write_gp(card
, gp
| clktab
[j
++]);
458 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
465 idt77252_eeprom_write_byte(struct idt77252_dev
*card
, u8 offset
, u8 data
)
470 gp
= idt77252_read_gp(card
) & ~(SAR_GP_EESCLK
|SAR_GP_EECS
|SAR_GP_EEDO
);
472 for (i
= 0; i
< sizeof(wrentab
)/sizeof(wrentab
[0]); i
++) {
473 idt77252_write_gp(card
, gp
| wrentab
[i
]);
476 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
479 for (i
= 0; i
< sizeof(wrtab
)/sizeof(wrtab
[0]); i
++) {
480 idt77252_write_gp(card
, gp
| wrtab
[i
]);
483 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
486 for (i
= 0, j
= 0; i
< 8; i
++) {
487 idt77252_write_gp(card
, gp
| clktab
[j
++] |
488 (offset
& 1 ? SAR_GP_EEDO
: 0));
491 idt77252_write_gp(card
, gp
| clktab
[j
++] |
492 (offset
& 1 ? SAR_GP_EEDO
: 0));
497 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
500 for (i
= 0, j
= 0; i
< 8; i
++) {
501 idt77252_write_gp(card
, gp
| clktab
[j
++] |
502 (data
& 1 ? SAR_GP_EEDO
: 0));
505 idt77252_write_gp(card
, gp
| clktab
[j
++] |
506 (data
& 1 ? SAR_GP_EEDO
: 0));
511 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
516 idt77252_eeprom_init(struct idt77252_dev
*card
)
520 gp
= idt77252_read_gp(card
) & ~(SAR_GP_EESCLK
|SAR_GP_EECS
|SAR_GP_EEDO
);
522 idt77252_write_gp(card
, gp
| SAR_GP_EECS
| SAR_GP_EESCLK
);
524 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
526 idt77252_write_gp(card
, gp
| SAR_GP_EECS
| SAR_GP_EESCLK
);
528 idt77252_write_gp(card
, gp
| SAR_GP_EECS
);
531 #endif /* HAVE_EEPROM */
534 #ifdef CONFIG_ATM_IDT77252_DEBUG
536 dump_tct(struct idt77252_dev
*card
, int index
)
541 tct
= (unsigned long) (card
->tct_base
+ index
* SAR_SRAM_TCT_SIZE
);
543 printk("%s: TCT %x:", card
->name
, index
);
544 for (i
= 0; i
< 8; i
++) {
545 printk(" %08x", read_sram(card
, tct
+ i
));
551 idt77252_tx_dump(struct idt77252_dev
*card
)
557 printk("%s\n", __FUNCTION__
);
558 for (i
= 0; i
< card
->tct_size
; i
++) {
572 printk("%s: Connection %d:\n", card
->name
, vc
->index
);
573 dump_tct(card
, vc
->index
);
579 /*****************************************************************************/
583 /*****************************************************************************/
586 sb_pool_add(struct idt77252_dev
*card
, struct sk_buff
*skb
, int queue
)
588 struct sb_pool
*pool
= &card
->sbpool
[queue
];
592 while (pool
->skb
[index
]) {
593 index
= (index
+ 1) & FBQ_MASK
;
594 if (index
== pool
->index
)
598 pool
->skb
[index
] = skb
;
599 IDT77252_PRV_POOL(skb
) = POOL_HANDLE(queue
, index
);
601 pool
->index
= (index
+ 1) & FBQ_MASK
;
606 sb_pool_remove(struct idt77252_dev
*card
, struct sk_buff
*skb
)
608 unsigned int queue
, index
;
611 handle
= IDT77252_PRV_POOL(skb
);
613 queue
= POOL_QUEUE(handle
);
617 index
= POOL_INDEX(handle
);
618 if (index
> FBQ_SIZE
- 1)
621 card
->sbpool
[queue
].skb
[index
] = NULL
;
624 static struct sk_buff
*
625 sb_pool_skb(struct idt77252_dev
*card
, u32 handle
)
627 unsigned int queue
, index
;
629 queue
= POOL_QUEUE(handle
);
633 index
= POOL_INDEX(handle
);
634 if (index
> FBQ_SIZE
- 1)
637 return card
->sbpool
[queue
].skb
[index
];
640 static struct scq_info
*
641 alloc_scq(struct idt77252_dev
*card
, int class)
643 struct scq_info
*scq
;
645 scq
= (struct scq_info
*) kmalloc(sizeof(struct scq_info
), GFP_KERNEL
);
648 memset(scq
, 0, sizeof(struct scq_info
));
650 scq
->base
= pci_alloc_consistent(card
->pcidev
, SCQ_SIZE
,
652 if (scq
->base
== NULL
) {
656 memset(scq
->base
, 0, SCQ_SIZE
);
658 scq
->next
= scq
->base
;
659 scq
->last
= scq
->base
+ (SCQ_ENTRIES
- 1);
660 atomic_set(&scq
->used
, 0);
662 spin_lock_init(&scq
->lock
);
663 spin_lock_init(&scq
->skblock
);
665 skb_queue_head_init(&scq
->transmit
);
666 skb_queue_head_init(&scq
->pending
);
668 TXPRINTK("idt77252: SCQ: base 0x%p, next 0x%p, last 0x%p, paddr %08x\n",
669 scq
->base
, scq
->next
, scq
->last
, scq
->paddr
);
675 free_scq(struct idt77252_dev
*card
, struct scq_info
*scq
)
680 pci_free_consistent(card
->pcidev
, SCQ_SIZE
,
681 scq
->base
, scq
->paddr
);
683 while ((skb
= skb_dequeue(&scq
->transmit
))) {
684 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
685 skb
->len
, PCI_DMA_TODEVICE
);
687 vcc
= ATM_SKB(skb
)->vcc
;
694 while ((skb
= skb_dequeue(&scq
->pending
))) {
695 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
696 skb
->len
, PCI_DMA_TODEVICE
);
698 vcc
= ATM_SKB(skb
)->vcc
;
710 push_on_scq(struct idt77252_dev
*card
, struct vc_map
*vc
, struct sk_buff
*skb
)
712 struct scq_info
*scq
= vc
->scq
;
717 TXPRINTK("%s: SCQ: next 0x%p\n", card
->name
, scq
->next
);
719 atomic_inc(&scq
->used
);
720 entries
= atomic_read(&scq
->used
);
721 if (entries
> (SCQ_ENTRIES
- 1)) {
722 atomic_dec(&scq
->used
);
726 skb_queue_tail(&scq
->transmit
, skb
);
728 spin_lock_irqsave(&vc
->lock
, flags
);
730 struct atm_vcc
*vcc
= vc
->tx_vcc
;
732 vc
->estimator
->cells
+= (skb
->len
+ 47) / 48;
733 if (atomic_read(&vcc
->tx_inuse
) > (vcc
->sk
->sndbuf
>> 1)) {
734 u32 cps
= vc
->estimator
->maxcps
;
736 vc
->estimator
->cps
= cps
;
737 vc
->estimator
->avcps
= cps
<< 5;
738 if (vc
->lacr
< vc
->init_er
) {
739 vc
->lacr
= vc
->init_er
;
740 writel(TCMDQ_LACR
| (vc
->lacr
<< 16) |
741 vc
->index
, SAR_REG_TCMDQ
);
745 spin_unlock_irqrestore(&vc
->lock
, flags
);
747 tbd
= &IDT77252_PRV_TBD(skb
);
749 spin_lock_irqsave(&scq
->lock
, flags
);
750 scq
->next
->word_1
= cpu_to_le32(tbd
->word_1
|
751 SAR_TBD_TSIF
| SAR_TBD_GTSI
);
752 scq
->next
->word_2
= cpu_to_le32(tbd
->word_2
);
753 scq
->next
->word_3
= cpu_to_le32(tbd
->word_3
);
754 scq
->next
->word_4
= cpu_to_le32(tbd
->word_4
);
756 if (scq
->next
== scq
->last
)
757 scq
->next
= scq
->base
;
761 write_sram(card
, scq
->scd
,
763 (u32
)((unsigned long)scq
->next
- (unsigned long)scq
->base
));
764 spin_unlock_irqrestore(&scq
->lock
, flags
);
766 scq
->trans_start
= jiffies
;
768 if (test_and_clear_bit(VCF_IDLE
, &vc
->flags
)) {
769 writel(TCMDQ_START_LACR
| (vc
->lacr
<< 16) | vc
->index
,
773 TXPRINTK("%d entries in SCQ used (push).\n", atomic_read(&scq
->used
));
775 XPRINTK("%s: SCQ (after push %2d) head = 0x%x, next = 0x%p.\n",
776 card
->name
, atomic_read(&scq
->used
),
777 read_sram(card
, scq
->scd
+ 1), scq
->next
);
782 if (jiffies
- scq
->trans_start
> HZ
) {
783 printk("%s: Error pushing TBD for %d.%d\n",
784 card
->name
, vc
->tx_vcc
->vpi
, vc
->tx_vcc
->vci
);
785 #ifdef CONFIG_ATM_IDT77252_DEBUG
786 idt77252_tx_dump(card
);
788 scq
->trans_start
= jiffies
;
796 drain_scq(struct idt77252_dev
*card
, struct vc_map
*vc
)
798 struct scq_info
*scq
= vc
->scq
;
802 TXPRINTK("%s: SCQ (before drain %2d) next = 0x%p.\n",
803 card
->name
, atomic_read(&scq
->used
), scq
->next
);
805 skb
= skb_dequeue(&scq
->transmit
);
807 TXPRINTK("%s: freeing skb at %p.\n", card
->name
, skb
);
809 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
810 skb
->len
, PCI_DMA_TODEVICE
);
812 vcc
= ATM_SKB(skb
)->vcc
;
819 atomic_inc(&vcc
->stats
->tx
);
822 atomic_dec(&scq
->used
);
824 spin_lock(&scq
->skblock
);
825 while ((skb
= skb_dequeue(&scq
->pending
))) {
826 if (push_on_scq(card
, vc
, skb
)) {
827 skb_queue_head(&vc
->scq
->pending
, skb
);
831 spin_unlock(&scq
->skblock
);
835 queue_skb(struct idt77252_dev
*card
, struct vc_map
*vc
,
836 struct sk_buff
*skb
, int oam
)
845 printk("%s: invalid skb->len (%d)\n", card
->name
, skb
->len
);
849 TXPRINTK("%s: Sending %d bytes of data.\n",
850 card
->name
, skb
->len
);
852 tbd
= &IDT77252_PRV_TBD(skb
);
853 vcc
= ATM_SKB(skb
)->vcc
;
855 IDT77252_PRV_PADDR(skb
) = pci_map_single(card
->pcidev
, skb
->data
,
856 skb
->len
, PCI_DMA_TODEVICE
);
864 tbd
->word_1
= SAR_TBD_OAM
| ATM_CELL_PAYLOAD
| SAR_TBD_EPDU
;
865 tbd
->word_2
= IDT77252_PRV_PADDR(skb
) + 4;
866 tbd
->word_3
= 0x00000000;
867 tbd
->word_4
= (skb
->data
[0] << 24) | (skb
->data
[1] << 16) |
868 (skb
->data
[2] << 8) | (skb
->data
[3] << 0);
870 if (test_bit(VCF_RSV
, &vc
->flags
))
876 if (test_bit(VCF_RSV
, &vc
->flags
)) {
877 printk("%s: Trying to transmit on reserved VC\n", card
->name
);
890 tbd
->word_1
= SAR_TBD_EPDU
| SAR_TBD_AAL0
|
893 tbd
->word_1
= SAR_TBD_EPDU
| SAR_TBD_AAL34
|
896 tbd
->word_2
= IDT77252_PRV_PADDR(skb
) + 4;
897 tbd
->word_3
= 0x00000000;
898 tbd
->word_4
= (skb
->data
[0] << 24) | (skb
->data
[1] << 16) |
899 (skb
->data
[2] << 8) | (skb
->data
[3] << 0);
903 tbd
->word_1
= SAR_TBD_EPDU
| SAR_TBD_AAL5
| skb
->len
;
904 tbd
->word_2
= IDT77252_PRV_PADDR(skb
);
905 tbd
->word_3
= skb
->len
;
906 tbd
->word_4
= (vcc
->vpi
<< SAR_TBD_VPI_SHIFT
) |
907 (vcc
->vci
<< SAR_TBD_VCI_SHIFT
);
913 printk("%s: Traffic type not supported.\n", card
->name
);
914 error
= -EPROTONOSUPPORT
;
919 spin_lock_irqsave(&vc
->scq
->skblock
, flags
);
920 skb_queue_tail(&vc
->scq
->pending
, skb
);
922 while ((skb
= skb_dequeue(&vc
->scq
->pending
))) {
923 if (push_on_scq(card
, vc
, skb
)) {
924 skb_queue_head(&vc
->scq
->pending
, skb
);
928 spin_unlock_irqrestore(&vc
->scq
->skblock
, flags
);
933 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
934 skb
->len
, PCI_DMA_TODEVICE
);
939 get_free_scd(struct idt77252_dev
*card
, struct vc_map
*vc
)
943 for (i
= 0; i
< card
->scd_size
; i
++) {
944 if (!card
->scd2vc
[i
]) {
945 card
->scd2vc
[i
] = vc
;
947 return card
->scd_base
+ i
* SAR_SRAM_SCD_SIZE
;
954 fill_scd(struct idt77252_dev
*card
, struct scq_info
*scq
, int class)
956 write_sram(card
, scq
->scd
, scq
->paddr
);
957 write_sram(card
, scq
->scd
+ 1, 0x00000000);
958 write_sram(card
, scq
->scd
+ 2, 0xffffffff);
959 write_sram(card
, scq
->scd
+ 3, 0x00000000);
963 clear_scd(struct idt77252_dev
*card
, struct scq_info
*scq
, int class)
968 /*****************************************************************************/
972 /*****************************************************************************/
975 init_rsq(struct idt77252_dev
*card
)
977 struct rsq_entry
*rsqe
;
979 card
->rsq
.base
= pci_alloc_consistent(card
->pcidev
, RSQSIZE
,
981 if (card
->rsq
.base
== NULL
) {
982 printk("%s: can't allocate RSQ.\n", card
->name
);
985 memset(card
->rsq
.base
, 0, RSQSIZE
);
987 card
->rsq
.last
= card
->rsq
.base
+ RSQ_NUM_ENTRIES
- 1;
988 card
->rsq
.next
= card
->rsq
.last
;
989 for (rsqe
= card
->rsq
.base
; rsqe
<= card
->rsq
.last
; rsqe
++)
992 writel((unsigned long) card
->rsq
.last
- (unsigned long) card
->rsq
.base
,
994 writel(card
->rsq
.paddr
, SAR_REG_RSQB
);
996 IPRINTK("%s: RSQ base at 0x%lx (0x%x).\n", card
->name
,
997 (unsigned long) card
->rsq
.base
,
998 readl(SAR_REG_RSQB
));
999 IPRINTK("%s: RSQ head = 0x%x, base = 0x%x, tail = 0x%x.\n",
1001 readl(SAR_REG_RSQH
),
1002 readl(SAR_REG_RSQB
),
1003 readl(SAR_REG_RSQT
));
1009 deinit_rsq(struct idt77252_dev
*card
)
1011 pci_free_consistent(card
->pcidev
, RSQSIZE
,
1012 card
->rsq
.base
, card
->rsq
.paddr
);
1016 dequeue_rx(struct idt77252_dev
*card
, struct rsq_entry
*rsqe
)
1018 struct atm_vcc
*vcc
;
1019 struct sk_buff
*skb
;
1020 struct rx_pool
*rpp
;
1022 u32 header
, vpi
, vci
;
1026 stat
= le32_to_cpu(rsqe
->word_4
);
1028 if (stat
& SAR_RSQE_IDLE
) {
1029 RXPRINTK("%s: message about inactive connection.\n",
1034 skb
= sb_pool_skb(card
, le32_to_cpu(rsqe
->word_2
));
1036 printk("%s: NULL skb in %s, rsqe: %08x %08x %08x %08x\n",
1037 card
->name
, __FUNCTION__
,
1038 le32_to_cpu(rsqe
->word_1
), le32_to_cpu(rsqe
->word_2
),
1039 le32_to_cpu(rsqe
->word_3
), le32_to_cpu(rsqe
->word_4
));
1043 header
= le32_to_cpu(rsqe
->word_1
);
1044 vpi
= (header
>> 16) & 0x00ff;
1045 vci
= (header
>> 0) & 0xffff;
1047 RXPRINTK("%s: SDU for %d.%d received in buffer 0x%p (data 0x%p).\n",
1048 card
->name
, vpi
, vci
, skb
, skb
->data
);
1050 if ((vpi
>= (1 << card
->vpibits
)) || (vci
!= (vci
& card
->vcimask
))) {
1051 printk("%s: SDU received for out-of-range vc %u.%u\n",
1052 card
->name
, vpi
, vci
);
1053 recycle_rx_skb(card
, skb
);
1057 vc
= card
->vcs
[VPCI2VC(card
, vpi
, vci
)];
1058 if (!vc
|| !test_bit(VCF_RX
, &vc
->flags
)) {
1059 printk("%s: SDU received on non RX vc %u.%u\n",
1060 card
->name
, vpi
, vci
);
1061 recycle_rx_skb(card
, skb
);
1067 pci_dma_sync_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
1068 skb
->end
- skb
->data
, PCI_DMA_FROMDEVICE
);
1070 if ((vcc
->qos
.aal
== ATM_AAL0
) ||
1071 (vcc
->qos
.aal
== ATM_AAL34
)) {
1073 unsigned char *cell
;
1077 for (i
= (stat
& SAR_RSQE_CELLCNT
); i
; i
--) {
1078 if ((sb
= dev_alloc_skb(64)) == NULL
) {
1079 printk("%s: Can't allocate buffers for aal0.\n",
1081 atomic_add(i
, &vcc
->stats
->rx_drop
);
1084 if (!atm_charge(vcc
, sb
->truesize
)) {
1085 RXPRINTK("%s: atm_charge() dropped aal0 packets.\n",
1087 atomic_add(i
- 1, &vcc
->stats
->rx_drop
);
1091 aal0
= (vpi
<< ATM_HDR_VPI_SHIFT
) |
1092 (vci
<< ATM_HDR_VCI_SHIFT
);
1093 aal0
|= (stat
& SAR_RSQE_EPDU
) ? 0x00000002 : 0;
1094 aal0
|= (stat
& SAR_RSQE_CLP
) ? 0x00000001 : 0;
1096 *((u32
*) sb
->data
) = aal0
;
1097 skb_put(sb
, sizeof(u32
));
1098 memcpy(skb_put(sb
, ATM_CELL_PAYLOAD
),
1099 cell
, ATM_CELL_PAYLOAD
);
1101 ATM_SKB(sb
)->vcc
= vcc
;
1102 do_gettimeofday(&sb
->stamp
);
1104 atomic_inc(&vcc
->stats
->rx
);
1106 cell
+= ATM_CELL_PAYLOAD
;
1109 recycle_rx_skb(card
, skb
);
1112 if (vcc
->qos
.aal
!= ATM_AAL5
) {
1113 printk("%s: Unexpected AAL type in dequeue_rx(): %d.\n",
1114 card
->name
, vcc
->qos
.aal
);
1115 recycle_rx_skb(card
, skb
);
1118 skb
->len
= (stat
& SAR_RSQE_CELLCNT
) * ATM_CELL_PAYLOAD
;
1120 rpp
= &vc
->rcv
.rx_pool
;
1122 rpp
->len
+= skb
->len
;
1126 rpp
->last
= &skb
->next
;
1128 if (stat
& SAR_RSQE_EPDU
) {
1129 unsigned char *l1l2
;
1132 l1l2
= (unsigned char *) ((unsigned long) skb
->data
+ skb
->len
- 6);
1134 len
= (l1l2
[0] << 8) | l1l2
[1];
1135 len
= len
? len
: 0x10000;
1137 RXPRINTK("%s: PDU has %d bytes.\n", card
->name
, len
);
1139 if ((len
+ 8 > rpp
->len
) || (len
+ (47 + 8) < rpp
->len
)) {
1140 RXPRINTK("%s: AAL5 PDU size mismatch: %d != %d. "
1142 card
->name
, len
, rpp
->len
, readl(SAR_REG_CDC
));
1143 recycle_rx_pool_skb(card
, rpp
);
1144 atomic_inc(&vcc
->stats
->rx_err
);
1147 if (stat
& SAR_RSQE_CRC
) {
1148 RXPRINTK("%s: AAL5 CRC error.\n", card
->name
);
1149 recycle_rx_pool_skb(card
, rpp
);
1150 atomic_inc(&vcc
->stats
->rx_err
);
1153 if (rpp
->count
> 1) {
1156 skb
= dev_alloc_skb(rpp
->len
);
1158 RXPRINTK("%s: Can't alloc RX skb.\n",
1160 recycle_rx_pool_skb(card
, rpp
);
1161 atomic_inc(&vcc
->stats
->rx_err
);
1164 if (!atm_charge(vcc
, skb
->truesize
)) {
1165 recycle_rx_pool_skb(card
, rpp
);
1170 for (i
= 0; i
< rpp
->count
; i
++) {
1171 memcpy(skb_put(skb
, sb
->len
),
1176 recycle_rx_pool_skb(card
, rpp
);
1179 ATM_SKB(skb
)->vcc
= vcc
;
1180 do_gettimeofday(&skb
->stamp
);
1182 vcc
->push(vcc
, skb
);
1183 atomic_inc(&vcc
->stats
->rx
);
1189 flush_rx_pool(card
, rpp
);
1191 if (!atm_charge(vcc
, skb
->truesize
)) {
1192 recycle_rx_skb(card
, skb
);
1196 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
1197 skb
->end
- skb
->data
, PCI_DMA_FROMDEVICE
);
1198 sb_pool_remove(card
, skb
);
1201 ATM_SKB(skb
)->vcc
= vcc
;
1202 do_gettimeofday(&skb
->stamp
);
1204 vcc
->push(vcc
, skb
);
1205 atomic_inc(&vcc
->stats
->rx
);
1207 if (skb
->truesize
> SAR_FB_SIZE_3
)
1208 add_rx_skb(card
, 3, SAR_FB_SIZE_3
, 1);
1209 else if (skb
->truesize
> SAR_FB_SIZE_2
)
1210 add_rx_skb(card
, 2, SAR_FB_SIZE_2
, 1);
1211 else if (skb
->truesize
> SAR_FB_SIZE_1
)
1212 add_rx_skb(card
, 1, SAR_FB_SIZE_1
, 1);
1214 add_rx_skb(card
, 0, SAR_FB_SIZE_0
, 1);
1220 idt77252_rx(struct idt77252_dev
*card
)
1222 struct rsq_entry
*rsqe
;
1224 if (card
->rsq
.next
== card
->rsq
.last
)
1225 rsqe
= card
->rsq
.base
;
1227 rsqe
= card
->rsq
.next
+ 1;
1229 if (!(le32_to_cpu(rsqe
->word_4
) & SAR_RSQE_VALID
)) {
1230 RXPRINTK("%s: no entry in RSQ.\n", card
->name
);
1235 dequeue_rx(card
, rsqe
);
1237 card
->rsq
.next
= rsqe
;
1238 if (card
->rsq
.next
== card
->rsq
.last
)
1239 rsqe
= card
->rsq
.base
;
1241 rsqe
= card
->rsq
.next
+ 1;
1242 } while (le32_to_cpu(rsqe
->word_4
) & SAR_RSQE_VALID
);
1244 writel((unsigned long) card
->rsq
.next
- (unsigned long) card
->rsq
.base
,
1249 idt77252_rx_raw(struct idt77252_dev
*card
)
1251 struct sk_buff
*queue
;
1253 struct atm_vcc
*vcc
;
1257 if (card
->raw_cell_head
== NULL
) {
1258 u32 handle
= le32_to_cpu(*(card
->raw_cell_hnd
+ 1));
1259 card
->raw_cell_head
= sb_pool_skb(card
, handle
);
1262 queue
= card
->raw_cell_head
;
1266 head
= IDT77252_PRV_PADDR(queue
) + (queue
->data
- queue
->head
- 16);
1267 tail
= readl(SAR_REG_RAWCT
);
1269 pci_dma_sync_single(card
->pcidev
, IDT77252_PRV_PADDR(queue
),
1270 queue
->end
- queue
->head
- 16, PCI_DMA_FROMDEVICE
);
1272 while (head
!= tail
) {
1273 unsigned int vpi
, vci
, pti
;
1276 header
= le32_to_cpu(*(u32
*) &queue
->data
[0]);
1278 vpi
= (header
& ATM_HDR_VPI_MASK
) >> ATM_HDR_VPI_SHIFT
;
1279 vci
= (header
& ATM_HDR_VCI_MASK
) >> ATM_HDR_VCI_SHIFT
;
1280 pti
= (header
& ATM_HDR_PTI_MASK
) >> ATM_HDR_PTI_SHIFT
;
1282 #ifdef CONFIG_ATM_IDT77252_DEBUG
1283 if (debug
& DBG_RAW_CELL
) {
1286 printk("%s: raw cell %x.%02x.%04x.%x.%x\n",
1287 card
->name
, (header
>> 28) & 0x000f,
1288 (header
>> 20) & 0x00ff,
1289 (header
>> 4) & 0xffff,
1290 (header
>> 1) & 0x0007,
1291 (header
>> 0) & 0x0001);
1292 for (i
= 16; i
< 64; i
++)
1293 printk(" %02x", queue
->data
[i
]);
1298 if (vpi
>= (1<<card
->vpibits
) || vci
>= (1<<card
->vcibits
)) {
1299 RPRINTK("%s: SDU received for out-of-range vc %u.%u\n",
1300 card
->name
, vpi
, vci
);
1304 vc
= card
->vcs
[VPCI2VC(card
, vpi
, vci
)];
1305 if (!vc
|| !test_bit(VCF_RX
, &vc
->flags
)) {
1306 RPRINTK("%s: SDU received on non RX vc %u.%u\n",
1307 card
->name
, vpi
, vci
);
1313 if (vcc
->qos
.aal
!= ATM_AAL0
) {
1314 RPRINTK("%s: raw cell for non AAL0 vc %u.%u\n",
1315 card
->name
, vpi
, vci
);
1316 atomic_inc(&vcc
->stats
->rx_drop
);
1320 if ((sb
= dev_alloc_skb(64)) == NULL
) {
1321 printk("%s: Can't allocate buffers for AAL0.\n",
1323 atomic_inc(&vcc
->stats
->rx_err
);
1327 if ((vcc
->sk
!= NULL
) && !atm_charge(vcc
, sb
->truesize
)) {
1328 RXPRINTK("%s: atm_charge() dropped AAL0 packets.\n",
1334 *((u32
*) sb
->data
) = header
;
1335 skb_put(sb
, sizeof(u32
));
1336 memcpy(skb_put(sb
, ATM_CELL_PAYLOAD
), &(queue
->data
[16]),
1339 ATM_SKB(sb
)->vcc
= vcc
;
1340 do_gettimeofday(&sb
->stamp
);
1342 atomic_inc(&vcc
->stats
->rx
);
1345 skb_pull(queue
, 64);
1347 head
= IDT77252_PRV_PADDR(queue
)
1348 + (queue
->data
- queue
->head
- 16);
1350 if (queue
->len
< 128) {
1351 struct sk_buff
*next
;
1354 head
= le32_to_cpu(*(u32
*) &queue
->data
[0]);
1355 handle
= le32_to_cpu(*(u32
*) &queue
->data
[4]);
1357 next
= sb_pool_skb(card
, handle
);
1358 recycle_rx_skb(card
, queue
);
1361 card
->raw_cell_head
= next
;
1362 queue
= card
->raw_cell_head
;
1363 pci_dma_sync_single(card
->pcidev
,
1364 IDT77252_PRV_PADDR(queue
),
1365 queue
->end
- queue
->data
,
1366 PCI_DMA_FROMDEVICE
);
1368 card
->raw_cell_head
= NULL
;
1369 printk("%s: raw cell queue overrun\n",
1378 /*****************************************************************************/
1382 /*****************************************************************************/
1385 init_tsq(struct idt77252_dev
*card
)
1387 struct tsq_entry
*tsqe
;
1389 card
->tsq
.base
= pci_alloc_consistent(card
->pcidev
, RSQSIZE
,
1391 if (card
->tsq
.base
== NULL
) {
1392 printk("%s: can't allocate TSQ.\n", card
->name
);
1395 memset(card
->tsq
.base
, 0, TSQSIZE
);
1397 card
->tsq
.last
= card
->tsq
.base
+ TSQ_NUM_ENTRIES
- 1;
1398 card
->tsq
.next
= card
->tsq
.last
;
1399 for (tsqe
= card
->tsq
.base
; tsqe
<= card
->tsq
.last
; tsqe
++)
1400 tsqe
->word_2
= cpu_to_le32(SAR_TSQE_INVALID
);
1402 writel(card
->tsq
.paddr
, SAR_REG_TSQB
);
1403 writel((unsigned long) card
->tsq
.next
- (unsigned long) card
->tsq
.base
,
1410 deinit_tsq(struct idt77252_dev
*card
)
1412 pci_free_consistent(card
->pcidev
, TSQSIZE
,
1413 card
->tsq
.base
, card
->tsq
.paddr
);
1417 idt77252_tx(struct idt77252_dev
*card
)
1419 struct tsq_entry
*tsqe
;
1420 unsigned int vpi
, vci
;
1424 if (card
->tsq
.next
== card
->tsq
.last
)
1425 tsqe
= card
->tsq
.base
;
1427 tsqe
= card
->tsq
.next
+ 1;
1429 TXPRINTK("idt77252_tx: tsq %p: base %p, next %p, last %p\n", tsqe
,
1430 card
->tsq
.base
, card
->tsq
.next
, card
->tsq
.last
);
1431 TXPRINTK("idt77252_tx: tsqb %08x, tsqt %08x, tsqh %08x, \n",
1432 readl(SAR_REG_TSQB
),
1433 readl(SAR_REG_TSQT
),
1434 readl(SAR_REG_TSQH
));
1436 stat
= le32_to_cpu(tsqe
->word_2
);
1438 if (stat
& SAR_TSQE_INVALID
)
1442 TXPRINTK("tsqe: 0x%p [0x%08x 0x%08x]\n", tsqe
,
1443 le32_to_cpu(tsqe
->word_1
),
1444 le32_to_cpu(tsqe
->word_2
));
1446 switch (stat
& SAR_TSQE_TYPE
) {
1447 case SAR_TSQE_TYPE_TIMER
:
1448 TXPRINTK("%s: Timer RollOver detected.\n", card
->name
);
1451 case SAR_TSQE_TYPE_IDLE
:
1453 conn
= le32_to_cpu(tsqe
->word_1
);
1455 if (SAR_TSQE_TAG(stat
) == 0x10) {
1457 printk("%s: Connection %d halted.\n",
1459 le32_to_cpu(tsqe
->word_1
) & 0x1fff);
1464 vc
= card
->vcs
[conn
& 0x1fff];
1466 printk("%s: could not find VC from conn %d\n",
1467 card
->name
, conn
& 0x1fff);
1471 printk("%s: Connection %d IDLE.\n",
1472 card
->name
, vc
->index
);
1474 set_bit(VCF_IDLE
, &vc
->flags
);
1477 case SAR_TSQE_TYPE_TSR
:
1479 conn
= le32_to_cpu(tsqe
->word_1
);
1481 vc
= card
->vcs
[conn
& 0x1fff];
1483 printk("%s: no VC at index %d\n",
1485 le32_to_cpu(tsqe
->word_1
) & 0x1fff);
1489 drain_scq(card
, vc
);
1492 case SAR_TSQE_TYPE_TBD_COMP
:
1494 conn
= le32_to_cpu(tsqe
->word_1
);
1496 vpi
= (conn
>> SAR_TBD_VPI_SHIFT
) & 0x00ff;
1497 vci
= (conn
>> SAR_TBD_VCI_SHIFT
) & 0xffff;
1499 if (vpi
>= (1 << card
->vpibits
) ||
1500 vci
>= (1 << card
->vcibits
)) {
1501 printk("%s: TBD complete: "
1502 "out of range VPI.VCI %u.%u\n",
1503 card
->name
, vpi
, vci
);
1507 vc
= card
->vcs
[VPCI2VC(card
, vpi
, vci
)];
1509 printk("%s: TBD complete: "
1510 "no VC at VPI.VCI %u.%u\n",
1511 card
->name
, vpi
, vci
);
1515 drain_scq(card
, vc
);
1519 tsqe
->word_2
= cpu_to_le32(SAR_TSQE_INVALID
);
1521 card
->tsq
.next
= tsqe
;
1522 if (card
->tsq
.next
== card
->tsq
.last
)
1523 tsqe
= card
->tsq
.base
;
1525 tsqe
= card
->tsq
.next
+ 1;
1527 TXPRINTK("tsqe: %p: base %p, next %p, last %p\n", tsqe
,
1528 card
->tsq
.base
, card
->tsq
.next
, card
->tsq
.last
);
1530 stat
= le32_to_cpu(tsqe
->word_2
);
1532 } while (!(stat
& SAR_TSQE_INVALID
));
1534 writel((unsigned long)card
->tsq
.next
- (unsigned long)card
->tsq
.base
,
1537 XPRINTK("idt77252_tx-after writel%d: TSQ head = 0x%x, tail = 0x%x, next = 0x%p.\n",
1538 card
->index
, readl(SAR_REG_TSQH
),
1539 readl(SAR_REG_TSQT
), card
->tsq
.next
);
1544 tst_timer(unsigned long data
)
1546 struct idt77252_dev
*card
= (struct idt77252_dev
*)data
;
1547 unsigned long base
, idle
, jump
;
1548 unsigned long flags
;
1552 spin_lock_irqsave(&card
->tst_lock
, flags
);
1554 base
= card
->tst
[card
->tst_index
];
1555 idle
= card
->tst
[card
->tst_index
^ 1];
1557 if (test_bit(TST_SWITCH_WAIT
, &card
->tst_state
)) {
1558 jump
= base
+ card
->tst_size
- 2;
1560 pc
= readl(SAR_REG_NOW
) >> 2;
1561 if ((pc
^ idle
) & ~(card
->tst_size
- 1)) {
1562 mod_timer(&card
->tst_timer
, jiffies
+ 1);
1566 clear_bit(TST_SWITCH_WAIT
, &card
->tst_state
);
1568 card
->tst_index
^= 1;
1569 write_sram(card
, jump
, TSTE_OPC_JMP
| (base
<< 2));
1571 base
= card
->tst
[card
->tst_index
];
1572 idle
= card
->tst
[card
->tst_index
^ 1];
1574 for (e
= 0; e
< card
->tst_size
- 2; e
++) {
1575 if (card
->soft_tst
[e
].tste
& TSTE_PUSH_IDLE
) {
1576 write_sram(card
, idle
+ e
,
1577 card
->soft_tst
[e
].tste
& TSTE_MASK
);
1578 card
->soft_tst
[e
].tste
&= ~(TSTE_PUSH_IDLE
);
1583 if (test_and_clear_bit(TST_SWITCH_PENDING
, &card
->tst_state
)) {
1585 for (e
= 0; e
< card
->tst_size
- 2; e
++) {
1586 if (card
->soft_tst
[e
].tste
& TSTE_PUSH_ACTIVE
) {
1587 write_sram(card
, idle
+ e
,
1588 card
->soft_tst
[e
].tste
& TSTE_MASK
);
1589 card
->soft_tst
[e
].tste
&= ~(TSTE_PUSH_ACTIVE
);
1590 card
->soft_tst
[e
].tste
|= TSTE_PUSH_IDLE
;
1594 jump
= base
+ card
->tst_size
- 2;
1596 write_sram(card
, jump
, TSTE_OPC_NULL
);
1597 set_bit(TST_SWITCH_WAIT
, &card
->tst_state
);
1599 mod_timer(&card
->tst_timer
, jiffies
+ 1);
1603 spin_unlock_irqrestore(&card
->tst_lock
, flags
);
1607 __fill_tst(struct idt77252_dev
*card
, struct vc_map
*vc
,
1608 int n
, unsigned int opc
)
1610 unsigned long cl
, avail
;
1615 avail
= card
->tst_size
- 2;
1616 for (e
= 0; e
< avail
; e
++) {
1617 if (card
->soft_tst
[e
].vc
== NULL
)
1621 printk("%s: No free TST entries found\n", card
->name
);
1625 NPRINTK("%s: conn %d: first TST entry at %d.\n",
1626 card
->name
, vc
? vc
->index
: -1, e
);
1630 data
= opc
& TSTE_OPC_MASK
;
1631 if (vc
&& (opc
!= TSTE_OPC_NULL
))
1632 data
= opc
| vc
->index
;
1634 idle
= card
->tst
[card
->tst_index
^ 1];
1640 if ((cl
>= avail
) && (card
->soft_tst
[e
].vc
== NULL
)) {
1642 card
->soft_tst
[e
].vc
= vc
;
1644 card
->soft_tst
[e
].vc
= (void *)-1;
1646 card
->soft_tst
[e
].tste
= data
;
1647 if (timer_pending(&card
->tst_timer
))
1648 card
->soft_tst
[e
].tste
|= TSTE_PUSH_ACTIVE
;
1650 write_sram(card
, idle
+ e
, data
);
1651 card
->soft_tst
[e
].tste
|= TSTE_PUSH_IDLE
;
1654 cl
-= card
->tst_size
;
1667 fill_tst(struct idt77252_dev
*card
, struct vc_map
*vc
, int n
, unsigned int opc
)
1669 unsigned long flags
;
1672 spin_lock_irqsave(&card
->tst_lock
, flags
);
1674 res
= __fill_tst(card
, vc
, n
, opc
);
1676 set_bit(TST_SWITCH_PENDING
, &card
->tst_state
);
1677 if (!timer_pending(&card
->tst_timer
))
1678 mod_timer(&card
->tst_timer
, jiffies
+ 1);
1680 spin_unlock_irqrestore(&card
->tst_lock
, flags
);
1685 __clear_tst(struct idt77252_dev
*card
, struct vc_map
*vc
)
1690 idle
= card
->tst
[card
->tst_index
^ 1];
1692 for (e
= 0; e
< card
->tst_size
- 2; e
++) {
1693 if (card
->soft_tst
[e
].vc
== vc
) {
1694 card
->soft_tst
[e
].vc
= NULL
;
1696 card
->soft_tst
[e
].tste
= TSTE_OPC_VAR
;
1697 if (timer_pending(&card
->tst_timer
))
1698 card
->soft_tst
[e
].tste
|= TSTE_PUSH_ACTIVE
;
1700 write_sram(card
, idle
+ e
, TSTE_OPC_VAR
);
1701 card
->soft_tst
[e
].tste
|= TSTE_PUSH_IDLE
;
1710 clear_tst(struct idt77252_dev
*card
, struct vc_map
*vc
)
1712 unsigned long flags
;
1715 spin_lock_irqsave(&card
->tst_lock
, flags
);
1717 res
= __clear_tst(card
, vc
);
1719 set_bit(TST_SWITCH_PENDING
, &card
->tst_state
);
1720 if (!timer_pending(&card
->tst_timer
))
1721 mod_timer(&card
->tst_timer
, jiffies
+ 1);
1723 spin_unlock_irqrestore(&card
->tst_lock
, flags
);
1728 change_tst(struct idt77252_dev
*card
, struct vc_map
*vc
,
1729 int n
, unsigned int opc
)
1731 unsigned long flags
;
1734 spin_lock_irqsave(&card
->tst_lock
, flags
);
1736 __clear_tst(card
, vc
);
1737 res
= __fill_tst(card
, vc
, n
, opc
);
1739 set_bit(TST_SWITCH_PENDING
, &card
->tst_state
);
1740 if (!timer_pending(&card
->tst_timer
))
1741 mod_timer(&card
->tst_timer
, jiffies
+ 1);
1743 spin_unlock_irqrestore(&card
->tst_lock
, flags
);
1749 set_tct(struct idt77252_dev
*card
, struct vc_map
*vc
)
1753 tct
= (unsigned long) (card
->tct_base
+ vc
->index
* SAR_SRAM_TCT_SIZE
);
1755 switch (vc
->class) {
1757 OPRINTK("%s: writing TCT at 0x%lx, SCD 0x%lx.\n",
1758 card
->name
, tct
, vc
->scq
->scd
);
1760 write_sram(card
, tct
+ 0, TCT_CBR
| vc
->scq
->scd
);
1761 write_sram(card
, tct
+ 1, 0);
1762 write_sram(card
, tct
+ 2, 0);
1763 write_sram(card
, tct
+ 3, 0);
1764 write_sram(card
, tct
+ 4, 0);
1765 write_sram(card
, tct
+ 5, 0);
1766 write_sram(card
, tct
+ 6, 0);
1767 write_sram(card
, tct
+ 7, 0);
1771 OPRINTK("%s: writing TCT at 0x%lx, SCD 0x%lx.\n",
1772 card
->name
, tct
, vc
->scq
->scd
);
1774 write_sram(card
, tct
+ 0, TCT_UBR
| vc
->scq
->scd
);
1775 write_sram(card
, tct
+ 1, 0);
1776 write_sram(card
, tct
+ 2, TCT_TSIF
);
1777 write_sram(card
, tct
+ 3, TCT_HALT
| TCT_IDLE
);
1778 write_sram(card
, tct
+ 4, 0);
1779 write_sram(card
, tct
+ 5, vc
->init_er
);
1780 write_sram(card
, tct
+ 6, 0);
1781 write_sram(card
, tct
+ 7, TCT_FLAG_UBR
);
1793 /*****************************************************************************/
1797 /*****************************************************************************/
1799 static __inline__
int
1800 idt77252_fbq_level(struct idt77252_dev
*card
, int queue
)
1802 return (readl(SAR_REG_STAT
) >> (16 + (queue
<< 2))) & 0x0f;
1805 static __inline__
int
1806 idt77252_fbq_full(struct idt77252_dev
*card
, int queue
)
1808 return (readl(SAR_REG_STAT
) >> (16 + (queue
<< 2))) == 0x0f;
1812 push_rx_skb(struct idt77252_dev
*card
, struct sk_buff
*skb
, int queue
)
1814 unsigned long flags
;
1818 skb
->data
= skb
->tail
= skb
->head
;
1821 skb_reserve(skb
, 16);
1825 skb_put(skb
, SAR_FB_SIZE_0
);
1828 skb_put(skb
, SAR_FB_SIZE_1
);
1831 skb_put(skb
, SAR_FB_SIZE_2
);
1834 skb_put(skb
, SAR_FB_SIZE_3
);
1841 if (idt77252_fbq_full(card
, queue
))
1844 memset(&skb
->data
[(skb
->len
& ~(0x3f)) - 64], 0, 2 * sizeof(u32
));
1846 handle
= IDT77252_PRV_POOL(skb
);
1847 addr
= IDT77252_PRV_PADDR(skb
);
1849 spin_lock_irqsave(&card
->cmd_lock
, flags
);
1850 writel(handle
, card
->fbq
[queue
]);
1851 writel(addr
, card
->fbq
[queue
]);
1852 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
1858 add_rx_skb(struct idt77252_dev
*card
, int queue
,
1859 unsigned int size
, unsigned int count
)
1861 struct sk_buff
*skb
;
1866 skb
= dev_alloc_skb(size
);
1870 if (sb_pool_add(card
, skb
, queue
)) {
1871 printk("%s: SB POOL full\n", __FUNCTION__
);
1875 paddr
= pci_map_single(card
->pcidev
, skb
->data
,
1876 skb
->end
- skb
->data
,
1877 PCI_DMA_FROMDEVICE
);
1878 IDT77252_PRV_PADDR(skb
) = paddr
;
1880 if (push_rx_skb(card
, skb
, queue
)) {
1881 printk("%s: FB QUEUE full\n", __FUNCTION__
);
1889 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
1890 skb
->end
- skb
->data
, PCI_DMA_FROMDEVICE
);
1892 handle
= IDT77252_PRV_POOL(skb
);
1893 card
->sbpool
[POOL_QUEUE(handle
)].skb
[POOL_INDEX(handle
)] = NULL
;
1901 recycle_rx_skb(struct idt77252_dev
*card
, struct sk_buff
*skb
)
1903 u32 handle
= IDT77252_PRV_POOL(skb
);
1906 err
= push_rx_skb(card
, skb
, POOL_QUEUE(handle
));
1908 pci_unmap_single(card
->pcidev
, IDT77252_PRV_PADDR(skb
),
1909 skb
->end
- skb
->data
, PCI_DMA_FROMDEVICE
);
1910 sb_pool_remove(card
, skb
);
1916 flush_rx_pool(struct idt77252_dev
*card
, struct rx_pool
*rpp
)
1921 rpp
->last
= &rpp
->first
;
1925 recycle_rx_pool_skb(struct idt77252_dev
*card
, struct rx_pool
*rpp
)
1927 struct sk_buff
*skb
, *next
;
1931 for (i
= 0; i
< rpp
->count
; i
++) {
1934 recycle_rx_skb(card
, skb
);
1937 flush_rx_pool(card
, rpp
);
1940 /*****************************************************************************/
1944 /*****************************************************************************/
1947 idt77252_phy_put(struct atm_dev
*dev
, unsigned char value
, unsigned long addr
)
1949 write_utility(dev
->dev_data
, 0x100 + (addr
& 0x1ff), value
);
1952 static unsigned char
1953 idt77252_phy_get(struct atm_dev
*dev
, unsigned long addr
)
1955 return read_utility(dev
->dev_data
, 0x100 + (addr
& 0x1ff));
1959 idt77252_send_skb(struct atm_vcc
*vcc
, struct sk_buff
*skb
, int oam
)
1961 struct atm_dev
*dev
= vcc
->dev
;
1962 struct idt77252_dev
*card
= dev
->dev_data
;
1963 struct vc_map
*vc
= vcc
->dev_data
;
1967 printk("%s: NULL connection in send().\n", card
->name
);
1968 atomic_inc(&vcc
->stats
->tx_err
);
1972 if (!test_bit(VCF_TX
, &vc
->flags
)) {
1973 printk("%s: Trying to transmit on a non-tx VC.\n", card
->name
);
1974 atomic_inc(&vcc
->stats
->tx_err
);
1979 switch (vcc
->qos
.aal
) {
1985 printk("%s: Unsupported AAL: %d\n", card
->name
, vcc
->qos
.aal
);
1986 atomic_inc(&vcc
->stats
->tx_err
);
1991 if (ATM_SKB(skb
)->iovcnt
!= 0) {
1992 printk("%s: No scatter-gather yet.\n", card
->name
);
1993 atomic_inc(&vcc
->stats
->tx_err
);
1997 ATM_SKB(skb
)->vcc
= vcc
;
1999 err
= queue_skb(card
, vc
, skb
, oam
);
2001 atomic_inc(&vcc
->stats
->tx_err
);
2010 idt77252_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
2012 return idt77252_send_skb(vcc
, skb
, 0);
2016 idt77252_send_oam(struct atm_vcc
*vcc
, void *cell
, int flags
)
2018 struct atm_dev
*dev
= vcc
->dev
;
2019 struct idt77252_dev
*card
= dev
->dev_data
;
2020 struct sk_buff
*skb
;
2022 skb
= dev_alloc_skb(64);
2024 printk("%s: Out of memory in send_oam().\n", card
->name
);
2025 atomic_inc(&vcc
->stats
->tx_err
);
2028 atomic_add(skb
->truesize
+ ATM_PDU_OVHD
, &vcc
->tx_inuse
);
2029 ATM_SKB(skb
)->iovcnt
= 0;
2031 memcpy(skb_put(skb
, 52), cell
, 52);
2033 return idt77252_send_skb(vcc
, skb
, 1);
2036 static __inline__
unsigned int
2037 idt77252_fls(unsigned int x
)
2043 if (x
& 0xffff0000) {
2065 idt77252_int_to_atmfp(unsigned int rate
)
2071 e
= idt77252_fls(rate
) - 1;
2073 m
= (rate
- (1 << e
)) << (9 - e
);
2075 m
= (rate
- (1 << e
));
2077 m
= (rate
- (1 << e
)) >> (e
- 9);
2078 return 0x4000 | (e
<< 9) | m
;
2082 idt77252_rate_logindex(struct idt77252_dev
*card
, int pcr
)
2086 afp
= idt77252_int_to_atmfp(pcr
< 0 ? -pcr
: pcr
);
2088 return rate_to_log
[(afp
>> 5) & 0x1ff];
2089 return rate_to_log
[((afp
>> 5) + 1) & 0x1ff];
2093 idt77252_est_timer(unsigned long data
)
2095 struct vc_map
*vc
= (struct vc_map
*)data
;
2096 struct idt77252_dev
*card
= vc
->card
;
2097 struct rate_estimator
*est
;
2098 unsigned long flags
;
2103 spin_lock_irqsave(&vc
->lock
, flags
);
2104 est
= vc
->estimator
;
2108 ncells
= est
->cells
;
2110 rate
= ((u32
)(ncells
- est
->last_cells
)) << (7 - est
->interval
);
2111 est
->last_cells
= ncells
;
2112 est
->avcps
+= ((long)rate
- (long)est
->avcps
) >> est
->ewma_log
;
2113 est
->cps
= (est
->avcps
+ 0x1f) >> 5;
2116 if (cps
< (est
->maxcps
>> 4))
2117 cps
= est
->maxcps
>> 4;
2119 lacr
= idt77252_rate_logindex(card
, cps
);
2120 if (lacr
> vc
->max_er
)
2123 if (lacr
!= vc
->lacr
) {
2125 writel(TCMDQ_LACR
|(vc
->lacr
<< 16)|vc
->index
, SAR_REG_TCMDQ
);
2128 est
->timer
.expires
= jiffies
+ ((HZ
/ 4) << est
->interval
);
2129 add_timer(&est
->timer
);
2132 spin_unlock_irqrestore(&vc
->lock
, flags
);
2135 static struct rate_estimator
*
2136 idt77252_init_est(struct vc_map
*vc
, int pcr
)
2138 struct rate_estimator
*est
;
2140 est
= kmalloc(sizeof(struct rate_estimator
), GFP_KERNEL
);
2143 memset(est
, 0, sizeof(*est
));
2145 est
->maxcps
= pcr
< 0 ? -pcr
: pcr
;
2146 est
->cps
= est
->maxcps
;
2147 est
->avcps
= est
->cps
<< 5;
2149 est
->interval
= 2; /* XXX: make this configurable */
2150 est
->ewma_log
= 2; /* XXX: make this configurable */
2151 init_timer(&est
->timer
);
2152 est
->timer
.data
= (unsigned long)vc
;
2153 est
->timer
.function
= idt77252_est_timer
;
2155 est
->timer
.expires
= jiffies
+ ((HZ
/ 4) << est
->interval
);
2156 add_timer(&est
->timer
);
2162 idt77252_init_cbr(struct idt77252_dev
*card
, struct vc_map
*vc
,
2163 struct atm_vcc
*vcc
, struct atm_qos
*qos
)
2165 int tst_free
, tst_used
, tst_entries
;
2166 unsigned long tmpl
, modl
;
2169 if ((qos
->txtp
.max_pcr
== 0) &&
2170 (qos
->txtp
.pcr
== 0) && (qos
->txtp
.min_pcr
== 0)) {
2171 printk("%s: trying to open a CBR VC with cell rate = 0\n",
2177 tst_free
= card
->tst_free
;
2178 if (test_bit(VCF_TX
, &vc
->flags
))
2179 tst_used
= vc
->ntste
;
2180 tst_free
+= tst_used
;
2182 tcr
= atm_pcr_goal(&qos
->txtp
);
2183 tcra
= tcr
>= 0 ? tcr
: -tcr
;
2185 TXPRINTK("%s: CBR target cell rate = %d\n", card
->name
, tcra
);
2187 tmpl
= (unsigned long) tcra
* ((unsigned long) card
->tst_size
- 2);
2188 modl
= tmpl
% (unsigned long)card
->utopia_pcr
;
2190 tst_entries
= (int) (tmpl
/ card
->utopia_pcr
);
2194 } else if (tcr
== 0) {
2195 tst_entries
= tst_free
- SAR_TST_RESERVED
;
2196 if (tst_entries
<= 0) {
2197 printk("%s: no CBR bandwidth free.\n", card
->name
);
2202 if (tst_entries
== 0) {
2203 printk("%s: selected CBR bandwidth < granularity.\n",
2208 if (tst_entries
> (tst_free
- SAR_TST_RESERVED
)) {
2209 printk("%s: not enough CBR bandwidth free.\n", card
->name
);
2213 vc
->ntste
= tst_entries
;
2215 card
->tst_free
= tst_free
- tst_entries
;
2216 if (test_bit(VCF_TX
, &vc
->flags
)) {
2217 if (tst_used
== tst_entries
)
2220 OPRINTK("%s: modify %d -> %d entries in TST.\n",
2221 card
->name
, tst_used
, tst_entries
);
2222 change_tst(card
, vc
, tst_entries
, TSTE_OPC_CBR
);
2226 OPRINTK("%s: setting %d entries in TST.\n", card
->name
, tst_entries
);
2227 fill_tst(card
, vc
, tst_entries
, TSTE_OPC_CBR
);
2232 idt77252_init_ubr(struct idt77252_dev
*card
, struct vc_map
*vc
,
2233 struct atm_vcc
*vcc
, struct atm_qos
*qos
)
2235 unsigned long flags
;
2238 spin_lock_irqsave(&vc
->lock
, flags
);
2239 if (vc
->estimator
) {
2240 del_timer(&vc
->estimator
->timer
);
2241 kfree(vc
->estimator
);
2242 vc
->estimator
= NULL
;
2244 spin_unlock_irqrestore(&vc
->lock
, flags
);
2246 tcr
= atm_pcr_goal(&qos
->txtp
);
2248 tcr
= card
->link_pcr
;
2250 vc
->estimator
= idt77252_init_est(vc
, tcr
);
2252 vc
->class = SCHED_UBR
;
2253 vc
->init_er
= idt77252_rate_logindex(card
, tcr
);
2254 vc
->lacr
= vc
->init_er
;
2256 vc
->max_er
= vc
->init_er
;
2264 idt77252_init_tx(struct idt77252_dev
*card
, struct vc_map
*vc
,
2265 struct atm_vcc
*vcc
, struct atm_qos
*qos
)
2269 if (test_bit(VCF_TX
, &vc
->flags
))
2272 switch (qos
->txtp
.traffic_class
) {
2274 vc
->class = SCHED_CBR
;
2278 vc
->class = SCHED_UBR
;
2284 return -EPROTONOSUPPORT
;
2287 vc
->scq
= alloc_scq(card
, vc
->class);
2289 printk("%s: can't get SCQ.\n", card
->name
);
2293 vc
->scq
->scd
= get_free_scd(card
, vc
);
2294 if (vc
->scq
->scd
== 0) {
2295 printk("%s: no SCD available.\n", card
->name
);
2296 free_scq(card
, vc
->scq
);
2300 fill_scd(card
, vc
->scq
, vc
->class);
2302 if (set_tct(card
, vc
)) {
2303 printk("%s: class %d not supported.\n",
2304 card
->name
, qos
->txtp
.traffic_class
);
2306 card
->scd2vc
[vc
->scd_index
] = NULL
;
2307 free_scq(card
, vc
->scq
);
2308 return -EPROTONOSUPPORT
;
2311 switch (vc
->class) {
2313 error
= idt77252_init_cbr(card
, vc
, vcc
, qos
);
2315 card
->scd2vc
[vc
->scd_index
] = NULL
;
2316 free_scq(card
, vc
->scq
);
2320 clear_bit(VCF_IDLE
, &vc
->flags
);
2321 writel(TCMDQ_START
| vc
->index
, SAR_REG_TCMDQ
);
2325 error
= idt77252_init_ubr(card
, vc
, vcc
, qos
);
2327 card
->scd2vc
[vc
->scd_index
] = NULL
;
2328 free_scq(card
, vc
->scq
);
2332 set_bit(VCF_IDLE
, &vc
->flags
);
2337 set_bit(VCF_TX
, &vc
->flags
);
2342 idt77252_init_rx(struct idt77252_dev
*card
, struct vc_map
*vc
,
2343 struct atm_vcc
*vcc
, struct atm_qos
*qos
)
2345 unsigned long flags
;
2349 if (test_bit(VCF_RX
, &vc
->flags
))
2353 set_bit(VCF_RX
, &vc
->flags
);
2355 if ((vcc
->vci
== 3) || (vcc
->vci
== 4))
2358 flush_rx_pool(card
, &vc
->rcv
.rx_pool
);
2360 rcte
|= SAR_RCTE_CONNECTOPEN
;
2361 rcte
|= SAR_RCTE_RAWCELLINTEN
;
2365 rcte
|= SAR_RCTE_RCQ
;
2368 rcte
|= SAR_RCTE_OAM
; /* Let SAR drop Video */
2371 rcte
|= SAR_RCTE_AAL34
;
2374 rcte
|= SAR_RCTE_AAL5
;
2377 rcte
|= SAR_RCTE_RCQ
;
2381 if (qos
->aal
!= ATM_AAL5
)
2382 rcte
|= SAR_RCTE_FBP_1
;
2383 else if (qos
->rxtp
.max_sdu
> SAR_FB_SIZE_2
)
2384 rcte
|= SAR_RCTE_FBP_3
;
2385 else if (qos
->rxtp
.max_sdu
> SAR_FB_SIZE_1
)
2386 rcte
|= SAR_RCTE_FBP_2
;
2387 else if (qos
->rxtp
.max_sdu
> SAR_FB_SIZE_0
)
2388 rcte
|= SAR_RCTE_FBP_1
;
2390 rcte
|= SAR_RCTE_FBP_01
;
2392 addr
= card
->rct_base
+ (vc
->index
<< 2);
2394 OPRINTK("%s: writing RCT at 0x%lx\n", card
->name
, addr
);
2395 write_sram(card
, addr
, rcte
);
2397 spin_lock_irqsave(&card
->cmd_lock
, flags
);
2398 writel(SAR_CMD_OPEN_CONNECTION
| (addr
<< 2), SAR_REG_CMD
);
2400 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
2406 idt77252_find_vcc(struct atm_vcc
*vcc
, short *vpi
, int *vci
)
2408 struct atm_vcc
*walk
;
2410 if (*vpi
== ATM_VPI_ANY
) {
2412 walk
= vcc
->dev
->vccs
;
2414 if ((walk
->vci
== *vci
) && (walk
->vpi
== *vpi
)) {
2416 walk
= vcc
->dev
->vccs
;
2423 if (*vci
== ATM_VCI_ANY
) {
2424 *vci
= ATM_NOT_RSV_VCI
;
2425 walk
= vcc
->dev
->vccs
;
2427 if ((walk
->vci
== *vci
) && (walk
->vpi
== *vpi
)) {
2429 walk
= vcc
->dev
->vccs
;
2440 idt77252_open(struct atm_vcc
*vcc
, short vpi
, int vci
)
2442 struct atm_dev
*dev
= vcc
->dev
;
2443 struct idt77252_dev
*card
= dev
->dev_data
;
2449 idt77252_find_vcc(vcc
, &vpi
, &vci
);
2451 if (vpi
== ATM_VPI_UNSPEC
|| vci
== ATM_VCI_UNSPEC
)
2454 if (vpi
>= (1 << card
->vpibits
)) {
2455 printk("%s: unsupported VPI: %d\n", card
->name
, vpi
);
2459 if (vci
>= (1 << card
->vcibits
)) {
2460 printk("%s: unsupported VCI: %d\n", card
->name
, vci
);
2466 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
2470 OPRINTK("%s: opening vpi.vci: %d.%d\n", card
->name
, vpi
, vci
);
2472 switch (vcc
->qos
.aal
) {
2478 printk("%s: Unsupported AAL: %d\n", card
->name
, vcc
->qos
.aal
);
2480 return -EPROTONOSUPPORT
;
2483 index
= VPCI2VC(card
, vpi
, vci
);
2484 if (!card
->vcs
[index
]) {
2485 card
->vcs
[index
] = kmalloc(sizeof(struct vc_map
), GFP_KERNEL
);
2486 if (!card
->vcs
[index
]) {
2487 printk("%s: can't alloc vc in open()\n", card
->name
);
2491 memset(card
->vcs
[index
], 0, sizeof(struct vc_map
));
2493 card
->vcs
[index
]->card
= card
;
2494 card
->vcs
[index
]->index
= index
;
2496 spin_lock_init(&card
->vcs
[index
]->lock
);
2498 vc
= card
->vcs
[index
];
2502 IPRINTK("%s: idt77252_open: vc = %d (%d.%d) %s/%s (max RX SDU: %u)\n",
2503 card
->name
, vc
->index
, vcc
->vpi
, vcc
->vci
,
2504 vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
? "rx" : "--",
2505 vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
? "tx" : "--",
2506 vcc
->qos
.rxtp
.max_sdu
);
2509 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
&&
2510 test_bit(VCF_TX
, &vc
->flags
))
2512 if (vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
&&
2513 test_bit(VCF_RX
, &vc
->flags
))
2517 printk("%s: %s vci already in use.\n", card
->name
,
2518 inuse
== 1 ? "tx" : inuse
== 2 ? "rx" : "tx and rx");
2523 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
) {
2524 error
= idt77252_init_tx(card
, vc
, vcc
, &vcc
->qos
);
2531 if (vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
) {
2532 error
= idt77252_init_rx(card
, vc
, vcc
, &vcc
->qos
);
2539 set_bit(ATM_VF_READY
, &vcc
->flags
);
2547 idt77252_close(struct atm_vcc
*vcc
)
2549 struct atm_dev
*dev
= vcc
->dev
;
2550 struct idt77252_dev
*card
= dev
->dev_data
;
2551 struct vc_map
*vc
= vcc
->dev_data
;
2552 unsigned long flags
;
2558 IPRINTK("%s: idt77252_close: vc = %d (%d.%d)\n",
2559 card
->name
, vc
->index
, vcc
->vpi
, vcc
->vci
);
2561 clear_bit(ATM_VF_READY
, &vcc
->flags
);
2563 if (vcc
->qos
.rxtp
.traffic_class
!= ATM_NONE
) {
2565 spin_lock_irqsave(&vc
->lock
, flags
);
2566 clear_bit(VCF_RX
, &vc
->flags
);
2568 spin_unlock_irqrestore(&vc
->lock
, flags
);
2570 if ((vcc
->vci
== 3) || (vcc
->vci
== 4))
2573 addr
= card
->rct_base
+ vc
->index
* SAR_SRAM_RCT_SIZE
;
2575 spin_lock_irqsave(&card
->cmd_lock
, flags
);
2576 writel(SAR_CMD_CLOSE_CONNECTION
| (addr
<< 2), SAR_REG_CMD
);
2578 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
2580 if (vc
->rcv
.rx_pool
.count
) {
2581 DPRINTK("%s: closing a VC with pending rx buffers.\n",
2584 recycle_rx_pool_skb(card
, &vc
->rcv
.rx_pool
);
2589 if (vcc
->qos
.txtp
.traffic_class
!= ATM_NONE
) {
2591 spin_lock_irqsave(&vc
->lock
, flags
);
2592 clear_bit(VCF_TX
, &vc
->flags
);
2593 clear_bit(VCF_IDLE
, &vc
->flags
);
2594 clear_bit(VCF_RSV
, &vc
->flags
);
2597 if (vc
->estimator
) {
2598 del_timer(&vc
->estimator
->timer
);
2599 kfree(vc
->estimator
);
2600 vc
->estimator
= NULL
;
2602 spin_unlock_irqrestore(&vc
->lock
, flags
);
2605 while (atomic_read(&vc
->scq
->used
) > 0) {
2606 timeout
= schedule_timeout(timeout
);
2611 printk("%s: SCQ drain timeout: %u used\n",
2612 card
->name
, atomic_read(&vc
->scq
->used
));
2614 writel(TCMDQ_HALT
| vc
->index
, SAR_REG_TCMDQ
);
2615 clear_scd(card
, vc
->scq
, vc
->class);
2617 if (vc
->class == SCHED_CBR
) {
2618 clear_tst(card
, vc
);
2619 card
->tst_free
+= vc
->ntste
;
2623 card
->scd2vc
[vc
->scd_index
] = NULL
;
2624 free_scq(card
, vc
->scq
);
2632 idt77252_change_qos(struct atm_vcc
*vcc
, struct atm_qos
*qos
, int flags
)
2634 struct atm_dev
*dev
= vcc
->dev
;
2635 struct idt77252_dev
*card
= dev
->dev_data
;
2636 struct vc_map
*vc
= vcc
->dev_data
;
2641 if (qos
->txtp
.traffic_class
!= ATM_NONE
) {
2642 if (!test_bit(VCF_TX
, &vc
->flags
)) {
2643 error
= idt77252_init_tx(card
, vc
, vcc
, qos
);
2647 switch (qos
->txtp
.traffic_class
) {
2649 error
= idt77252_init_cbr(card
, vc
, vcc
, qos
);
2655 error
= idt77252_init_ubr(card
, vc
, vcc
, qos
);
2659 if (!test_bit(VCF_IDLE
, &vc
->flags
)) {
2660 writel(TCMDQ_LACR
| (vc
->lacr
<< 16) |
2661 vc
->index
, SAR_REG_TCMDQ
);
2667 error
= -EOPNOTSUPP
;
2673 if ((qos
->rxtp
.traffic_class
!= ATM_NONE
) &&
2674 !test_bit(VCF_RX
, &vc
->flags
)) {
2675 error
= idt77252_init_rx(card
, vc
, vcc
, qos
);
2680 memcpy(&vcc
->qos
, qos
, sizeof(struct atm_qos
));
2682 set_bit(ATM_VF_HASQOS
, &vcc
->flags
);
2690 idt77252_proc_read(struct atm_dev
*dev
, loff_t
* pos
, char *page
)
2692 struct idt77252_dev
*card
= dev
->dev_data
;
2697 return sprintf(page
, "IDT77252 Interrupts:\n");
2699 return sprintf(page
, "TSIF: %lu\n", card
->irqstat
[15]);
2701 return sprintf(page
, "TXICP: %lu\n", card
->irqstat
[14]);
2703 return sprintf(page
, "TSQF: %lu\n", card
->irqstat
[12]);
2705 return sprintf(page
, "TMROF: %lu\n", card
->irqstat
[11]);
2707 return sprintf(page
, "PHYI: %lu\n", card
->irqstat
[10]);
2709 return sprintf(page
, "FBQ3A: %lu\n", card
->irqstat
[8]);
2711 return sprintf(page
, "FBQ2A: %lu\n", card
->irqstat
[7]);
2713 return sprintf(page
, "RSQF: %lu\n", card
->irqstat
[6]);
2715 return sprintf(page
, "EPDU: %lu\n", card
->irqstat
[5]);
2717 return sprintf(page
, "RAWCF: %lu\n", card
->irqstat
[4]);
2719 return sprintf(page
, "FBQ1A: %lu\n", card
->irqstat
[3]);
2721 return sprintf(page
, "FBQ0A: %lu\n", card
->irqstat
[2]);
2723 return sprintf(page
, "RSQAF: %lu\n", card
->irqstat
[1]);
2725 return sprintf(page
, "IDT77252 Transmit Connection Table:\n");
2727 for (i
= 0; i
< card
->tct_size
; i
++) {
2729 struct atm_vcc
*vcc
;
2746 p
+= sprintf(p
, " %4u: %u.%u: ", i
, vcc
->vpi
, vcc
->vci
);
2747 tct
= (unsigned long) (card
->tct_base
+ i
* SAR_SRAM_TCT_SIZE
);
2749 for (i
= 0; i
< 8; i
++)
2750 p
+= sprintf(p
, " %08x", read_sram(card
, tct
+ i
));
2751 p
+= sprintf(p
, "\n");
2757 /*****************************************************************************/
2759 /* Interrupt handler */
2761 /*****************************************************************************/
2764 idt77252_collect_stat(struct idt77252_dev
*card
)
2768 cdc
= readl(SAR_REG_CDC
);
2769 vpec
= readl(SAR_REG_VPEC
);
2770 icc
= readl(SAR_REG_ICC
);
2773 printk("%s:", card
->name
);
2775 if (cdc
& 0x7f0000) {
2779 if (cdc
& (1 << 22)) {
2780 printk("%sRM ID", s
);
2783 if (cdc
& (1 << 21)) {
2784 printk("%sCON TAB", s
);
2787 if (cdc
& (1 << 20)) {
2788 printk("%sNO FB", s
);
2791 if (cdc
& (1 << 19)) {
2792 printk("%sOAM CRC", s
);
2795 if (cdc
& (1 << 18)) {
2796 printk("%sRM CRC", s
);
2799 if (cdc
& (1 << 17)) {
2800 printk("%sRM FIFO", s
);
2803 if (cdc
& (1 << 16)) {
2804 printk("%sRX FIFO", s
);
2810 printk(" CDC %04x, VPEC %04x, ICC: %04x\n",
2811 cdc
& 0xffff, vpec
& 0xffff, icc
& 0xffff);
2816 idt77252_interrupt(int irq
, void *dev_id
, struct pt_regs
*ptregs
)
2818 struct idt77252_dev
*card
= dev_id
;
2821 stat
= readl(SAR_REG_STAT
) & 0xffff;
2822 if (!stat
) /* no interrupt for us */
2825 if (test_and_set_bit(IDT77252_BIT_INTERRUPT
, &card
->flags
)) {
2826 printk("%s: Re-entering irq_handler()\n", card
->name
);
2830 writel(stat
, SAR_REG_STAT
); /* reset interrupt */
2832 if (stat
& SAR_STAT_TSIF
) { /* entry written to TSQ */
2833 INTPRINTK("%s: TSIF\n", card
->name
);
2834 card
->irqstat
[15]++;
2837 if (stat
& SAR_STAT_TXICP
) { /* Incomplete CS-PDU has */
2838 INTPRINTK("%s: TXICP\n", card
->name
);
2839 card
->irqstat
[14]++;
2840 #ifdef CONFIG_ATM_IDT77252_DEBUG
2841 idt77252_tx_dump(card
);
2844 if (stat
& SAR_STAT_TSQF
) { /* TSQ 7/8 full */
2845 INTPRINTK("%s: TSQF\n", card
->name
);
2846 card
->irqstat
[12]++;
2849 if (stat
& SAR_STAT_TMROF
) { /* Timer overflow */
2850 INTPRINTK("%s: TMROF\n", card
->name
);
2851 card
->irqstat
[11]++;
2852 idt77252_collect_stat(card
);
2855 if (stat
& SAR_STAT_EPDU
) { /* Got complete CS-PDU */
2856 INTPRINTK("%s: EPDU\n", card
->name
);
2860 if (stat
& SAR_STAT_RSQAF
) { /* RSQ is 7/8 full */
2861 INTPRINTK("%s: RSQAF\n", card
->name
);
2865 if (stat
& SAR_STAT_RSQF
) { /* RSQ is full */
2866 INTPRINTK("%s: RSQF\n", card
->name
);
2870 if (stat
& SAR_STAT_RAWCF
) { /* Raw cell received */
2871 INTPRINTK("%s: RAWCF\n", card
->name
);
2873 idt77252_rx_raw(card
);
2876 if (stat
& SAR_STAT_PHYI
) { /* PHY device interrupt */
2877 INTPRINTK("%s: PHYI", card
->name
);
2878 card
->irqstat
[10]++;
2879 if (card
->atmdev
->phy
&& card
->atmdev
->phy
->interrupt
)
2880 card
->atmdev
->phy
->interrupt(card
->atmdev
);
2883 if (stat
& (SAR_STAT_FBQ0A
| SAR_STAT_FBQ1A
|
2884 SAR_STAT_FBQ2A
| SAR_STAT_FBQ3A
)) {
2886 writel(readl(SAR_REG_CFG
) & ~(SAR_CFG_FBIE
), SAR_REG_CFG
);
2888 INTPRINTK("%s: FBQA: %04x\n", card
->name
, stat
);
2890 if (stat
& SAR_STAT_FBQ0A
)
2892 if (stat
& SAR_STAT_FBQ1A
)
2894 if (stat
& SAR_STAT_FBQ2A
)
2896 if (stat
& SAR_STAT_FBQ3A
)
2899 schedule_work(&card
->tqueue
);
2903 clear_bit(IDT77252_BIT_INTERRUPT
, &card
->flags
);
2907 idt77252_softint(void *dev_id
)
2909 struct idt77252_dev
*card
= dev_id
;
2913 for (done
= 1; ; done
= 1) {
2914 stat
= readl(SAR_REG_STAT
) >> 16;
2916 if ((stat
& 0x0f) < SAR_FBQ0_HIGH
) {
2917 add_rx_skb(card
, 0, SAR_FB_SIZE_0
, 32);
2922 if ((stat
& 0x0f) < SAR_FBQ1_HIGH
) {
2923 add_rx_skb(card
, 1, SAR_FB_SIZE_1
, 32);
2928 if ((stat
& 0x0f) < SAR_FBQ2_HIGH
) {
2929 add_rx_skb(card
, 2, SAR_FB_SIZE_2
, 32);
2934 if ((stat
& 0x0f) < SAR_FBQ3_HIGH
) {
2935 add_rx_skb(card
, 3, SAR_FB_SIZE_3
, 32);
2943 writel(readl(SAR_REG_CFG
) | SAR_CFG_FBIE
, SAR_REG_CFG
);
2948 open_card_oam(struct idt77252_dev
*card
)
2950 unsigned long flags
;
2957 for (vpi
= 0; vpi
< (1 << card
->vpibits
); vpi
++) {
2958 for (vci
= 3; vci
< 5; vci
++) {
2959 index
= VPCI2VC(card
, vpi
, vci
);
2961 vc
= kmalloc(sizeof(struct vc_map
), GFP_KERNEL
);
2963 printk("%s: can't alloc vc\n", card
->name
);
2966 memset(vc
, 0, sizeof(struct vc_map
));
2969 card
->vcs
[index
] = vc
;
2971 flush_rx_pool(card
, &vc
->rcv
.rx_pool
);
2973 rcte
= SAR_RCTE_CONNECTOPEN
|
2974 SAR_RCTE_RAWCELLINTEN
|
2978 addr
= card
->rct_base
+ (vc
->index
<< 2);
2979 write_sram(card
, addr
, rcte
);
2981 spin_lock_irqsave(&card
->cmd_lock
, flags
);
2982 writel(SAR_CMD_OPEN_CONNECTION
| (addr
<< 2),
2985 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
2993 close_card_oam(struct idt77252_dev
*card
)
2995 unsigned long flags
;
3001 for (vpi
= 0; vpi
< (1 << card
->vpibits
); vpi
++) {
3002 for (vci
= 3; vci
< 5; vci
++) {
3003 index
= VPCI2VC(card
, vpi
, vci
);
3004 vc
= card
->vcs
[index
];
3006 addr
= card
->rct_base
+ vc
->index
* SAR_SRAM_RCT_SIZE
;
3008 spin_lock_irqsave(&card
->cmd_lock
, flags
);
3009 writel(SAR_CMD_CLOSE_CONNECTION
| (addr
<< 2),
3012 spin_unlock_irqrestore(&card
->cmd_lock
, flags
);
3014 if (vc
->rcv
.rx_pool
.count
) {
3015 DPRINTK("%s: closing a VC "
3016 "with pending rx buffers.\n",
3019 recycle_rx_pool_skb(card
, &vc
->rcv
.rx_pool
);
3026 open_card_ubr0(struct idt77252_dev
*card
)
3030 vc
= kmalloc(sizeof(struct vc_map
), GFP_KERNEL
);
3032 printk("%s: can't alloc vc\n", card
->name
);
3035 memset(vc
, 0, sizeof(struct vc_map
));
3037 vc
->class = SCHED_UBR0
;
3039 vc
->scq
= alloc_scq(card
, vc
->class);
3041 printk("%s: can't get SCQ.\n", card
->name
);
3045 card
->scd2vc
[0] = vc
;
3047 vc
->scq
->scd
= card
->scd_base
;
3049 fill_scd(card
, vc
->scq
, vc
->class);
3051 write_sram(card
, card
->tct_base
+ 0, TCT_UBR
| card
->scd_base
);
3052 write_sram(card
, card
->tct_base
+ 1, 0);
3053 write_sram(card
, card
->tct_base
+ 2, 0);
3054 write_sram(card
, card
->tct_base
+ 3, 0);
3055 write_sram(card
, card
->tct_base
+ 4, 0);
3056 write_sram(card
, card
->tct_base
+ 5, 0);
3057 write_sram(card
, card
->tct_base
+ 6, 0);
3058 write_sram(card
, card
->tct_base
+ 7, TCT_FLAG_UBR
);
3060 clear_bit(VCF_IDLE
, &vc
->flags
);
3061 writel(TCMDQ_START
| 0, SAR_REG_TCMDQ
);
3066 idt77252_dev_open(struct idt77252_dev
*card
)
3070 if (!test_bit(IDT77252_BIT_INIT
, &card
->flags
)) {
3071 printk("%s: SAR not yet initialized.\n", card
->name
);
3075 conf
= SAR_CFG_RXPTH
| /* enable receive path */
3076 SAR_RX_DELAY
| /* interrupt on complete PDU */
3077 SAR_CFG_RAWIE
| /* interrupt enable on raw cells */
3078 SAR_CFG_RQFIE
| /* interrupt on RSQ almost full */
3079 SAR_CFG_TMOIE
| /* interrupt on timer overflow */
3080 SAR_CFG_FBIE
| /* interrupt on low free buffers */
3081 SAR_CFG_TXEN
| /* transmit operation enable */
3082 SAR_CFG_TXINT
| /* interrupt on transmit status */
3083 SAR_CFG_TXUIE
| /* interrupt on transmit underrun */
3084 SAR_CFG_TXSFI
| /* interrupt on TSQ almost full */
3085 SAR_CFG_PHYIE
/* enable PHY interrupts */
3088 #ifdef CONFIG_ATM_IDT77252_RCV_ALL
3089 /* Test RAW cell receive. */
3090 conf
|= SAR_CFG_VPECA
;
3093 writel(readl(SAR_REG_CFG
) | conf
, SAR_REG_CFG
);
3095 if (open_card_oam(card
)) {
3096 printk("%s: Error initializing OAM.\n", card
->name
);
3100 if (open_card_ubr0(card
)) {
3101 printk("%s: Error initializing UBR0.\n", card
->name
);
3105 IPRINTK("%s: opened IDT77252 ABR SAR.\n", card
->name
);
3110 idt77252_dev_close(struct atm_dev
*dev
)
3112 struct idt77252_dev
*card
= dev
->dev_data
;
3115 close_card_oam(card
);
3117 conf
= SAR_CFG_RXPTH
| /* enable receive path */
3118 SAR_RX_DELAY
| /* interrupt on complete PDU */
3119 SAR_CFG_RAWIE
| /* interrupt enable on raw cells */
3120 SAR_CFG_RQFIE
| /* interrupt on RSQ almost full */
3121 SAR_CFG_TMOIE
| /* interrupt on timer overflow */
3122 SAR_CFG_FBIE
| /* interrupt on low free buffers */
3123 SAR_CFG_TXEN
| /* transmit operation enable */
3124 SAR_CFG_TXINT
| /* interrupt on transmit status */
3125 SAR_CFG_TXUIE
| /* interrupt on xmit underrun */
3126 SAR_CFG_TXSFI
/* interrupt on TSQ almost full */
3129 writel(readl(SAR_REG_CFG
) & ~(conf
), SAR_REG_CFG
);
3131 DIPRINTK("%s: closed IDT77252 ABR SAR.\n", card
->name
);
3135 /*****************************************************************************/
3137 /* Initialisation and Deinitialization of IDT77252 */
3139 /*****************************************************************************/
3143 deinit_card(struct idt77252_dev
*card
)
3145 struct sk_buff
*skb
;
3148 if (!test_bit(IDT77252_BIT_INIT
, &card
->flags
)) {
3149 printk("%s: SAR not yet initialized.\n", card
->name
);
3152 DIPRINTK("idt77252: deinitialize card %u\n", card
->index
);
3154 writel(0, SAR_REG_CFG
);
3157 atm_dev_deregister(card
->atmdev
);
3159 for (i
= 0; i
< 4; i
++) {
3160 for (j
= 0; j
< FBQ_SIZE
; j
++) {
3161 skb
= card
->sbpool
[i
].skb
[j
];
3163 pci_unmap_single(card
->pcidev
,
3164 IDT77252_PRV_PADDR(skb
),
3165 skb
->end
- skb
->data
,
3166 PCI_DMA_FROMDEVICE
);
3167 card
->sbpool
[i
].skb
[j
] = NULL
;
3174 vfree(card
->soft_tst
);
3177 vfree(card
->scd2vc
);
3182 if (card
->raw_cell_hnd
) {
3183 pci_free_consistent(card
->pcidev
, 2 * sizeof(u32
),
3184 card
->raw_cell_hnd
, card
->raw_cell_paddr
);
3187 if (card
->rsq
.base
) {
3188 DIPRINTK("%s: Release RSQ ...\n", card
->name
);
3192 if (card
->tsq
.base
) {
3193 DIPRINTK("%s: Release TSQ ...\n", card
->name
);
3197 DIPRINTK("idt77252: Release IRQ.\n");
3198 free_irq(card
->pcidev
->irq
, card
);
3200 for (i
= 0; i
< 4; i
++) {
3202 iounmap((void *) card
->fbq
[i
]);
3206 iounmap((void *) card
->membase
);
3208 clear_bit(IDT77252_BIT_INIT
, &card
->flags
);
3209 DIPRINTK("%s: Card deinitialized.\n", card
->name
);
3213 static int __devinit
3214 init_sram(struct idt77252_dev
*card
)
3218 for (i
= 0; i
< card
->sramsize
; i
+= 4)
3219 write_sram(card
, (i
>> 2), 0);
3221 /* set SRAM layout for THIS card */
3222 if (card
->sramsize
== (512 * 1024)) {
3223 card
->tct_base
= SAR_SRAM_TCT_128_BASE
;
3224 card
->tct_size
= (SAR_SRAM_TCT_128_TOP
- card
->tct_base
+ 1)
3225 / SAR_SRAM_TCT_SIZE
;
3226 card
->rct_base
= SAR_SRAM_RCT_128_BASE
;
3227 card
->rct_size
= (SAR_SRAM_RCT_128_TOP
- card
->rct_base
+ 1)
3228 / SAR_SRAM_RCT_SIZE
;
3229 card
->rt_base
= SAR_SRAM_RT_128_BASE
;
3230 card
->scd_base
= SAR_SRAM_SCD_128_BASE
;
3231 card
->scd_size
= (SAR_SRAM_SCD_128_TOP
- card
->scd_base
+ 1)
3232 / SAR_SRAM_SCD_SIZE
;
3233 card
->tst
[0] = SAR_SRAM_TST1_128_BASE
;
3234 card
->tst
[1] = SAR_SRAM_TST2_128_BASE
;
3235 card
->tst_size
= SAR_SRAM_TST1_128_TOP
- card
->tst
[0] + 1;
3236 card
->abrst_base
= SAR_SRAM_ABRSTD_128_BASE
;
3237 card
->abrst_size
= SAR_ABRSTD_SIZE_8K
;
3238 card
->fifo_base
= SAR_SRAM_FIFO_128_BASE
;
3239 card
->fifo_size
= SAR_RXFD_SIZE_32K
;
3241 card
->tct_base
= SAR_SRAM_TCT_32_BASE
;
3242 card
->tct_size
= (SAR_SRAM_TCT_32_TOP
- card
->tct_base
+ 1)
3243 / SAR_SRAM_TCT_SIZE
;
3244 card
->rct_base
= SAR_SRAM_RCT_32_BASE
;
3245 card
->rct_size
= (SAR_SRAM_RCT_32_TOP
- card
->rct_base
+ 1)
3246 / SAR_SRAM_RCT_SIZE
;
3247 card
->rt_base
= SAR_SRAM_RT_32_BASE
;
3248 card
->scd_base
= SAR_SRAM_SCD_32_BASE
;
3249 card
->scd_size
= (SAR_SRAM_SCD_32_TOP
- card
->scd_base
+ 1)
3250 / SAR_SRAM_SCD_SIZE
;
3251 card
->tst
[0] = SAR_SRAM_TST1_32_BASE
;
3252 card
->tst
[1] = SAR_SRAM_TST2_32_BASE
;
3253 card
->tst_size
= (SAR_SRAM_TST1_32_TOP
- card
->tst
[0] + 1);
3254 card
->abrst_base
= SAR_SRAM_ABRSTD_32_BASE
;
3255 card
->abrst_size
= SAR_ABRSTD_SIZE_1K
;
3256 card
->fifo_base
= SAR_SRAM_FIFO_32_BASE
;
3257 card
->fifo_size
= SAR_RXFD_SIZE_4K
;
3260 /* Initialize TCT */
3261 for (i
= 0; i
< card
->tct_size
; i
++) {
3262 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 0, 0);
3263 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 1, 0);
3264 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 2, 0);
3265 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 3, 0);
3266 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 4, 0);
3267 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 5, 0);
3268 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 6, 0);
3269 write_sram(card
, i
* SAR_SRAM_TCT_SIZE
+ 7, 0);
3272 /* Initialize RCT */
3273 for (i
= 0; i
< card
->rct_size
; i
++) {
3274 write_sram(card
, card
->rct_base
+ i
* SAR_SRAM_RCT_SIZE
,
3275 (u32
) SAR_RCTE_RAWCELLINTEN
);
3276 write_sram(card
, card
->rct_base
+ i
* SAR_SRAM_RCT_SIZE
+ 1,
3278 write_sram(card
, card
->rct_base
+ i
* SAR_SRAM_RCT_SIZE
+ 2,
3280 write_sram(card
, card
->rct_base
+ i
* SAR_SRAM_RCT_SIZE
+ 3,
3284 writel((SAR_FBQ0_LOW
<< 28) | 0x00000000 | 0x00000000 |
3285 (SAR_FB_SIZE_0
/ 48), SAR_REG_FBQS0
);
3286 writel((SAR_FBQ1_LOW
<< 28) | 0x00000000 | 0x00000000 |
3287 (SAR_FB_SIZE_1
/ 48), SAR_REG_FBQS1
);
3288 writel((SAR_FBQ2_LOW
<< 28) | 0x00000000 | 0x00000000 |
3289 (SAR_FB_SIZE_2
/ 48), SAR_REG_FBQS2
);
3290 writel((SAR_FBQ3_LOW
<< 28) | 0x00000000 | 0x00000000 |
3291 (SAR_FB_SIZE_3
/ 48), SAR_REG_FBQS3
);
3293 /* Initialize rate table */
3294 for (i
= 0; i
< 256; i
++) {
3295 write_sram(card
, card
->rt_base
+ i
, log_to_rate
[i
]);
3298 for (i
= 0; i
< 128; i
++) {
3301 tmp
= rate_to_log
[(i
<< 2) + 0] << 0;
3302 tmp
|= rate_to_log
[(i
<< 2) + 1] << 8;
3303 tmp
|= rate_to_log
[(i
<< 2) + 2] << 16;
3304 tmp
|= rate_to_log
[(i
<< 2) + 3] << 24;
3305 write_sram(card
, card
->rt_base
+ 256 + i
, tmp
);
3308 #if 0 /* Fill RDF and AIR tables. */
3309 for (i
= 0; i
< 128; i
++) {
3312 tmp
= RDF
[0][(i
<< 1) + 0] << 16;
3313 tmp
|= RDF
[0][(i
<< 1) + 1] << 0;
3314 write_sram(card
, card
->rt_base
+ 512 + i
, tmp
);
3317 for (i
= 0; i
< 128; i
++) {
3320 tmp
= AIR
[0][(i
<< 1) + 0] << 16;
3321 tmp
|= AIR
[0][(i
<< 1) + 1] << 0;
3322 write_sram(card
, card
->rt_base
+ 640 + i
, tmp
);
3326 IPRINTK("%s: initialize rate table ...\n", card
->name
);
3327 writel(card
->rt_base
<< 2, SAR_REG_RTBL
);
3329 /* Initialize TSTs */
3330 IPRINTK("%s: initialize TST ...\n", card
->name
);
3331 card
->tst_free
= card
->tst_size
- 2; /* last two are jumps */
3333 for (i
= card
->tst
[0]; i
< card
->tst
[0] + card
->tst_size
- 2; i
++)
3334 write_sram(card
, i
, TSTE_OPC_VAR
);
3335 write_sram(card
, i
++, TSTE_OPC_JMP
| (card
->tst
[0] << 2));
3336 idt77252_sram_write_errors
= 1;
3337 write_sram(card
, i
++, TSTE_OPC_JMP
| (card
->tst
[1] << 2));
3338 idt77252_sram_write_errors
= 0;
3339 for (i
= card
->tst
[1]; i
< card
->tst
[1] + card
->tst_size
- 2; i
++)
3340 write_sram(card
, i
, TSTE_OPC_VAR
);
3341 write_sram(card
, i
++, TSTE_OPC_JMP
| (card
->tst
[1] << 2));
3342 idt77252_sram_write_errors
= 1;
3343 write_sram(card
, i
++, TSTE_OPC_JMP
| (card
->tst
[0] << 2));
3344 idt77252_sram_write_errors
= 0;
3346 card
->tst_index
= 0;
3347 writel(card
->tst
[0] << 2, SAR_REG_TSTB
);
3349 /* Initialize ABRSTD and Receive FIFO */
3350 IPRINTK("%s: initialize ABRSTD ...\n", card
->name
);
3351 writel(card
->abrst_size
| (card
->abrst_base
<< 2),
3354 IPRINTK("%s: initialize receive fifo ...\n", card
->name
);
3355 writel(card
->fifo_size
| (card
->fifo_base
<< 2),
3358 IPRINTK("%s: SRAM initialization complete.\n", card
->name
);
3362 static int __devinit
3363 init_card(struct atm_dev
*dev
)
3365 struct idt77252_dev
*card
= dev
->dev_data
;
3366 struct pci_dev
*pcidev
= card
->pcidev
;
3367 unsigned long tmpl
, modl
;
3368 unsigned int linkrate
, rsvdcr
;
3369 unsigned int tst_entries
;
3370 struct net_device
*tmp
;
3378 if (test_bit(IDT77252_BIT_INIT
, &card
->flags
)) {
3379 printk("Error: SAR already initialized.\n");
3383 /*****************************************************************/
3384 /* P C I C O N F I G U R A T I O N */
3385 /*****************************************************************/
3387 /* Set PCI Retry-Timeout and TRDY timeout */
3388 IPRINTK("%s: Checking PCI retries.\n", card
->name
);
3389 if (pci_read_config_byte(pcidev
, 0x40, &pci_byte
) != 0) {
3390 printk("%s: can't read PCI retry timeout.\n", card
->name
);
3394 if (pci_byte
!= 0) {
3395 IPRINTK("%s: PCI retry timeout: %d, set to 0.\n",
3396 card
->name
, pci_byte
);
3397 if (pci_write_config_byte(pcidev
, 0x40, 0) != 0) {
3398 printk("%s: can't set PCI retry timeout.\n",
3404 IPRINTK("%s: Checking PCI TRDY.\n", card
->name
);
3405 if (pci_read_config_byte(pcidev
, 0x41, &pci_byte
) != 0) {
3406 printk("%s: can't read PCI TRDY timeout.\n", card
->name
);
3410 if (pci_byte
!= 0) {
3411 IPRINTK("%s: PCI TRDY timeout: %d, set to 0.\n",
3412 card
->name
, pci_byte
);
3413 if (pci_write_config_byte(pcidev
, 0x41, 0) != 0) {
3414 printk("%s: can't set PCI TRDY timeout.\n", card
->name
);
3419 /* Reset Timer register */
3420 if (readl(SAR_REG_STAT
) & SAR_STAT_TMROF
) {
3421 printk("%s: resetting timer overflow.\n", card
->name
);
3422 writel(SAR_STAT_TMROF
, SAR_REG_STAT
);
3424 IPRINTK("%s: Request IRQ ... ", card
->name
);
3425 if (request_irq(pcidev
->irq
, idt77252_interrupt
, SA_INTERRUPT
|SA_SHIRQ
,
3426 card
->name
, card
) != 0) {
3427 printk("%s: can't allocate IRQ.\n", card
->name
);
3431 IPRINTK("got %d.\n", pcidev
->irq
);
3433 /*****************************************************************/
3434 /* C H E C K A N D I N I T S R A M */
3435 /*****************************************************************/
3437 IPRINTK("%s: Initializing SRAM\n", card
->name
);
3439 /* preset size of connecton table, so that init_sram() knows about it */
3440 conf
= SAR_CFG_TX_FIFO_SIZE_9
| /* Use maximum fifo size */
3441 SAR_CFG_RXSTQ_SIZE_8k
| /* Receive Status Queue is 8k */
3442 SAR_CFG_IDLE_CLP
| /* Set CLP on idle cells */
3443 #ifndef CONFIG_ATM_IDT77252_SEND_IDLE
3444 SAR_CFG_NO_IDLE
| /* Do not send idle cells */
3448 if (card
->sramsize
== (512 * 1024))
3449 conf
|= SAR_CFG_CNTBL_1k
;
3451 conf
|= SAR_CFG_CNTBL_512
;
3455 conf
|= SAR_CFG_VPVCS_0
;
3459 conf
|= SAR_CFG_VPVCS_1
;
3462 conf
|= SAR_CFG_VPVCS_2
;
3465 conf
|= SAR_CFG_VPVCS_8
;
3469 writel(readl(SAR_REG_CFG
) | conf
, SAR_REG_CFG
);
3471 if (init_sram(card
) < 0)
3474 /********************************************************************/
3475 /* A L L O C R A M A N D S E T V A R I O U S T H I N G S */
3476 /********************************************************************/
3477 /* Initialize TSQ */
3478 if (0 != init_tsq(card
)) {
3482 /* Initialize RSQ */
3483 if (0 != init_rsq(card
)) {
3488 card
->vpibits
= vpibits
;
3489 if (card
->sramsize
== (512 * 1024)) {
3490 card
->vcibits
= 10 - card
->vpibits
;
3492 card
->vcibits
= 9 - card
->vpibits
;
3496 for (k
= 0, i
= 1; k
< card
->vcibits
; k
++) {
3501 IPRINTK("%s: Setting VPI/VCI mask to zero.\n", card
->name
);
3502 writel(0, SAR_REG_VPM
);
3504 /* Little Endian Order */
3505 writel(0, SAR_REG_GP
);
3507 /* Initialize RAW Cell Handle Register */
3508 card
->raw_cell_hnd
= pci_alloc_consistent(card
->pcidev
, 2 * sizeof(u32
),
3509 &card
->raw_cell_paddr
);
3510 if (!card
->raw_cell_hnd
) {
3511 printk("%s: memory allocation failure.\n", card
->name
);
3515 memset(card
->raw_cell_hnd
, 0, 2 * sizeof(u32
));
3516 writel(card
->raw_cell_paddr
, SAR_REG_RAWHND
);
3517 IPRINTK("%s: raw cell handle is at 0x%p.\n", card
->name
,
3518 card
->raw_cell_hnd
);
3520 size
= sizeof(struct vc_map
*) * card
->tct_size
;
3521 IPRINTK("%s: allocate %d byte for VC map.\n", card
->name
, size
);
3522 if (NULL
== (card
->vcs
= vmalloc(size
))) {
3523 printk("%s: memory allocation failure.\n", card
->name
);
3527 memset(card
->vcs
, 0, size
);
3529 size
= sizeof(struct vc_map
*) * card
->scd_size
;
3530 IPRINTK("%s: allocate %d byte for SCD to VC mapping.\n",
3532 if (NULL
== (card
->scd2vc
= vmalloc(size
))) {
3533 printk("%s: memory allocation failure.\n", card
->name
);
3537 memset(card
->scd2vc
, 0, size
);
3539 size
= sizeof(struct tst_info
) * (card
->tst_size
- 2);
3540 IPRINTK("%s: allocate %d byte for TST to VC mapping.\n",
3542 if (NULL
== (card
->soft_tst
= vmalloc(size
))) {
3543 printk("%s: memory allocation failure.\n", card
->name
);
3547 for (i
= 0; i
< card
->tst_size
- 2; i
++) {
3548 card
->soft_tst
[i
].tste
= TSTE_OPC_VAR
;
3549 card
->soft_tst
[i
].vc
= NULL
;
3552 if (dev
->phy
== NULL
) {
3553 printk("%s: No LT device defined.\n", card
->name
);
3557 if (dev
->phy
->ioctl
== NULL
) {
3558 printk("%s: LT had no IOCTL funtion defined.\n", card
->name
);
3563 #ifdef CONFIG_ATM_IDT77252_USE_SUNI
3565 * this is a jhs hack to get around special functionality in the
3566 * phy driver for the atecom hardware; the functionality doesn't
3567 * exist in the linux atm suni driver
3569 * it isn't the right way to do things, but as the guy from NIST
3570 * said, talking about their measurement of the fine structure
3571 * constant, "it's good enough for government work."
3573 linkrate
= 149760000;
3576 card
->link_pcr
= (linkrate
/ 8 / 53);
3577 printk("%s: Linkrate on ATM line : %u bit/s, %u cell/s.\n",
3578 card
->name
, linkrate
, card
->link_pcr
);
3580 #ifdef CONFIG_ATM_IDT77252_SEND_IDLE
3581 card
->utopia_pcr
= card
->link_pcr
;
3583 card
->utopia_pcr
= (160000000 / 8 / 54);
3587 if (card
->utopia_pcr
> card
->link_pcr
)
3588 rsvdcr
= card
->utopia_pcr
- card
->link_pcr
;
3590 tmpl
= (unsigned long) rsvdcr
* ((unsigned long) card
->tst_size
- 2);
3591 modl
= tmpl
% (unsigned long)card
->utopia_pcr
;
3592 tst_entries
= (int) (tmpl
/ (unsigned long)card
->utopia_pcr
);
3595 card
->tst_free
-= tst_entries
;
3596 fill_tst(card
, NULL
, tst_entries
, TSTE_OPC_NULL
);
3599 idt77252_eeprom_init(card
);
3600 printk("%s: EEPROM: %02x:", card
->name
,
3601 idt77252_eeprom_read_status(card
));
3603 for (i
= 0; i
< 0x80; i
++) {
3605 idt77252_eeprom_read_byte(card
, i
)
3609 #endif /* HAVE_EEPROM */
3614 sprintf(tname
, "eth%d", card
->index
);
3615 tmp
= dev_get_by_name(tname
); /* jhs: was "tmp = dev_get(tname);" */
3617 memcpy(card
->atmdev
->esi
, tmp
->dev_addr
, 6);
3619 printk("%s: ESI %02x:%02x:%02x:%02x:%02x:%02x\n",
3620 card
->name
, card
->atmdev
->esi
[0], card
->atmdev
->esi
[1],
3621 card
->atmdev
->esi
[2], card
->atmdev
->esi
[3],
3622 card
->atmdev
->esi
[4], card
->atmdev
->esi
[5]);
3628 /* Set Maximum Deficit Count for now. */
3629 writel(0xffff, SAR_REG_MDFCT
);
3631 set_bit(IDT77252_BIT_INIT
, &card
->flags
);
3633 XPRINTK("%s: IDT77252 ABR SAR initialization complete.\n", card
->name
);
3638 /*****************************************************************************/
3640 /* Probing of IDT77252 ABR SAR */
3642 /*****************************************************************************/
3645 static int __devinit
3646 idt77252_preset(struct idt77252_dev
*card
)
3650 /*****************************************************************/
3651 /* P C I C O N F I G U R A T I O N */
3652 /*****************************************************************/
3654 XPRINTK("%s: Enable PCI master and memory access for SAR.\n",
3656 if (pci_read_config_word(card
->pcidev
, PCI_COMMAND
, &pci_command
)) {
3657 printk("%s: can't read PCI_COMMAND.\n", card
->name
);
3661 if (!(pci_command
& PCI_COMMAND_IO
)) {
3662 printk("%s: PCI_COMMAND: %04x (???)\n",
3663 card
->name
, pci_command
);
3667 pci_command
|= (PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
);
3668 if (pci_write_config_word(card
->pcidev
, PCI_COMMAND
, pci_command
)) {
3669 printk("%s: can't write PCI_COMMAND.\n", card
->name
);
3673 /*****************************************************************/
3674 /* G E N E R I C R E S E T */
3675 /*****************************************************************/
3677 /* Software reset */
3678 writel(SAR_CFG_SWRST
, SAR_REG_CFG
);
3680 writel(0, SAR_REG_CFG
);
3682 IPRINTK("%s: Software resetted.\n", card
->name
);
3687 static unsigned long __devinit
3688 probe_sram(struct idt77252_dev
*card
)
3692 writel(0, SAR_REG_DR0
);
3693 writel(SAR_CMD_WRITE_SRAM
| (0 << 2), SAR_REG_CMD
);
3695 for (addr
= 0x4000; addr
< 0x80000; addr
+= 0x4000) {
3696 writel(0xdeadbeef, SAR_REG_DR0
);
3697 writel(SAR_CMD_WRITE_SRAM
| (addr
<< 2), SAR_REG_CMD
);
3699 writel(SAR_CMD_READ_SRAM
| (0 << 2), SAR_REG_CMD
);
3700 data
= readl(SAR_REG_DR0
);
3706 return addr
* sizeof(u32
);
3709 static int __devinit
3710 idt77252_init_one(struct pci_dev
*pcidev
, const struct pci_device_id
*id
)
3712 static struct idt77252_dev
**last
= &idt77252_chain
;
3713 static int index
= 0;
3715 unsigned long membase
, srambase
;
3716 struct idt77252_dev
*card
;
3717 struct atm_dev
*dev
;
3718 ushort revision
= 0;
3722 if (pci_read_config_word(pcidev
, PCI_REVISION_ID
, &revision
)) {
3723 printk("idt77252-%d: can't read PCI_REVISION_ID\n", index
);
3727 card
= kmalloc(sizeof(struct idt77252_dev
), GFP_KERNEL
);
3729 printk("idt77252-%d: can't allocate private data\n", index
);
3732 memset(card
, 0, sizeof(struct idt77252_dev
));
3734 card
->revision
= revision
;
3735 card
->index
= index
;
3736 card
->pcidev
= pcidev
;
3737 sprintf(card
->name
, "idt77252-%d", card
->index
);
3739 INIT_WORK(&card
->tqueue
, idt77252_softint
, (void *)card
);
3741 membase
= pci_resource_start(pcidev
, 1);
3742 srambase
= pci_resource_start(pcidev
, 2);
3744 init_MUTEX(&card
->mutex
);
3745 spin_lock_init(&card
->cmd_lock
);
3746 spin_lock_init(&card
->tst_lock
);
3748 init_timer(&card
->tst_timer
);
3749 card
->tst_timer
.data
= (unsigned long)card
;
3750 card
->tst_timer
.function
= tst_timer
;
3752 /* Do the I/O remapping... */
3753 card
->membase
= (unsigned long) ioremap(membase
, 1024);
3754 if (!card
->membase
) {
3755 printk("%s: can't ioremap() membase\n", card
->name
);
3760 if (idt77252_preset(card
)) {
3761 printk("%s: preset failed\n", card
->name
);
3762 iounmap((void *) card
->membase
);
3767 dev
= atm_dev_register("idt77252", &idt77252_ops
, -1, 0);
3769 printk("%s: can't register atm device\n", card
->name
);
3770 iounmap((void *) card
->membase
);
3774 dev
->dev_data
= card
;
3777 #ifdef CONFIG_ATM_IDT77252_USE_SUNI
3780 printk("%s: can't init SUNI\n", card
->name
);
3785 #endif /* CONFIG_ATM_IDT77252_USE_SUNI */
3787 card
->sramsize
= probe_sram(card
);
3789 for (i
= 0; i
< 4; i
++) {
3790 card
->fbq
[i
] = (unsigned long)
3791 ioremap(srambase
| 0x200000 | (i
<< 18), 4);
3792 if (!card
->fbq
[i
]) {
3793 printk("%s: can't ioremap() FBQ%d\n", card
->name
, i
);
3800 printk("%s: ABR SAR (Rev %c): MEM %08lx SRAM %08lx [%u KB]\n",
3801 card
->name
, ((revision
> 1) && (revision
< 25)) ?
3802 'A' + revision
- 1 : '?', membase
, srambase
,
3803 card
->sramsize
/ 1024);
3805 if (init_card(dev
)) {
3806 printk("%s: init_card failed\n", card
->name
);
3812 dev
->ci_range
.vpi_bits
= card
->vpibits
;
3813 dev
->ci_range
.vci_bits
= card
->vcibits
;
3814 dev
->link_rate
= card
->link_pcr
;
3816 if (dev
->phy
->start
)
3817 dev
->phy
->start(dev
);
3819 if (idt77252_dev_open(card
)) {
3820 printk("%s: dev_open failed\n", card
->name
);
3823 dev
->phy
->stop(dev
);
3836 static struct pci_device_id idt77252_pci_tbl
[] __devinitdata
=
3838 { PCI_VENDOR_ID_IDT
, PCI_DEVICE_ID_IDT_IDT77252
,
3839 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0 },
3843 static struct pci_driver idt77252_driver
= {
3845 .id_table
= idt77252_pci_tbl
,
3846 .probe
= idt77252_init_one
,
3849 static int __init
idt77252_init(void)
3851 struct sk_buff
*skb
;
3853 printk("%s: at %p\n", __FUNCTION__
, idt77252_init
);
3855 if (sizeof(skb
->cb
) < sizeof(struct atm_skb_data
) +
3856 sizeof(struct idt77252_skb_prv
)) {
3857 printk(KERN_ERR
"%s: skb->cb is too small (%lu < %lu)\n",
3858 __FUNCTION__
, (unsigned long) sizeof(skb
->cb
),
3859 (unsigned long) sizeof(struct atm_skb_data
) +
3860 sizeof(struct idt77252_skb_prv
));
3864 if (pci_register_driver(&idt77252_driver
) > 0)
3867 pci_unregister_driver(&idt77252_driver
);
3871 static void __exit
idt77252_exit(void)
3873 struct idt77252_dev
*card
;
3874 struct atm_dev
*dev
;
3876 pci_unregister_driver(&idt77252_driver
);
3878 while (idt77252_chain
) {
3879 card
= idt77252_chain
;
3881 idt77252_chain
= card
->next
;
3884 dev
->phy
->stop(dev
);
3889 DIPRINTK("idt77252: finished cleanup-module().\n");
3892 module_init(idt77252_init
);
3893 module_exit(idt77252_exit
);
3895 MODULE_LICENSE("GPL");
3897 MODULE_PARM(vpibits
, "i");
3898 MODULE_PARM_DESC(vpibits
, "number of VPI bits supported (0, 1, or 2)");
3899 #ifdef CONFIG_ATM_IDT77252_DEBUG
3900 MODULE_PARM(debug
, "i");
3901 MODULE_PARM_DESC(debug
, "debug bitmap, see drivers/atm/idt77252.h");
3904 MODULE_AUTHOR("Eddie C. Dost <ecd@atecom.com>");
3905 MODULE_DESCRIPTION("IDT77252 ABR SAR Driver");