[linux.git] / drivers / atm / idt77105.c

// SPDX-License-Identifier: GPL-2.0-only
/* drivers/atm/idt77105.c - IDT77105 (PHY) driver */
 
/* Written 1999 by Greg Banks, NEC Australia <[email protected]>. Based on suni.c */


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/atmdev.h>
#include <linux/sonet.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/capability.h>
#include <linux/atm_idt77105.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <asm/param.h>
#include <linux/uaccess.h>

#include "idt77105.h"

#undef GENERAL_DEBUG

#ifdef GENERAL_DEBUG
#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
#else
#define DPRINTK(format,args...)
#endif


struct idt77105_priv {
	struct idt77105_stats stats;    /* link diagnostics */
	struct atm_dev *dev;		/* device back-pointer */
	struct idt77105_priv *next;
        int loop_mode;
        unsigned char old_mcr;          /* storage of MCR reg while signal lost */
};

static DEFINE_SPINLOCK(idt77105_priv_lock);

#define PRIV(dev) ((struct idt77105_priv *) dev->phy_data)

#define PUT(val,reg) dev->ops->phy_put(dev,val,IDT77105_##reg)
#define GET(reg) dev->ops->phy_get(dev,IDT77105_##reg)

static void idt77105_stats_timer_func(struct timer_list *);
static void idt77105_restart_timer_func(struct timer_list *);


static DEFINE_TIMER(stats_timer, idt77105_stats_timer_func);
static DEFINE_TIMER(restart_timer, idt77105_restart_timer_func);
static int start_timer = 1;
static struct idt77105_priv *idt77105_all = NULL;

/*
 * Retrieve the value of one of the IDT77105's counters.
 * `counter' is one of the IDT77105_CTRSEL_* constants.
 */
static u16 get_counter(struct atm_dev *dev, int counter)
{
        u16 val;
        
        /* write the counter bit into PHY register 6 */
        PUT(counter, CTRSEL);
        /* read the low 8 bits from register 4 */
        val = GET(CTRLO);
        /* read the high 8 bits from register 5 */
        val |= GET(CTRHI)<<8;
        
        return val;
}

/*
 * Timer function called every second to gather statistics
 * from the 77105. This is done because the h/w registers
 * will overflow if not read at least once per second. The
 * kernel's stats are much higher precision. Also, having
 * a separate copy of the stats allows implementation of
 * an ioctl which gathers the stats *without* zero'ing them.
 */
static void idt77105_stats_timer_func(struct timer_list *unused)
{
	struct idt77105_priv *walk;
	struct atm_dev *dev;
	struct idt77105_stats *stats;

        DPRINTK("IDT77105 gathering statistics\n");
	for (walk = idt77105_all; walk; walk = walk->next) {
		dev = walk->dev;
                
		stats = &walk->stats;
                stats->symbol_errors += get_counter(dev, IDT77105_CTRSEL_SEC);
                stats->tx_cells += get_counter(dev, IDT77105_CTRSEL_TCC);
                stats->rx_cells += get_counter(dev, IDT77105_CTRSEL_RCC);
                stats->rx_hec_errors += get_counter(dev, IDT77105_CTRSEL_RHEC);
	}
        if (!start_timer) mod_timer(&stats_timer,jiffies+IDT77105_STATS_TIMER_PERIOD);
}


/*
 * A separate timer func which handles restarting PHY chips which
 * have had the cable re-inserted after being pulled out. This is
 * done by polling the Good Signal Bit in the Interrupt Status
 * register every 5 seconds. The other technique (checking Good
 * Signal Bit in the interrupt handler) cannot be used because PHY
 * interrupts need to be disabled when the cable is pulled out
 * to avoid lots of spurious cell error interrupts.
 */
static void idt77105_restart_timer_func(struct timer_list *unused)
{
	struct idt77105_priv *walk;
	struct atm_dev *dev;
        unsigned char istat;

        DPRINTK("IDT77105 checking for cable re-insertion\n");
	for (walk = idt77105_all; walk; walk = walk->next) {
		dev = walk->dev;
                
                if (dev->signal != ATM_PHY_SIG_LOST)
                    continue;
                    
                istat = GET(ISTAT); /* side effect: clears all interrupt status bits */
                if (istat & IDT77105_ISTAT_GOODSIG) {
                    /* Found signal again */
                    atm_dev_signal_change(dev, ATM_PHY_SIG_FOUND);
	            printk(KERN_NOTICE "%s(itf %d): signal detected again\n",
                        dev->type,dev->number);
                    /* flush the receive FIFO */
                    PUT( GET(DIAG) | IDT77105_DIAG_RFLUSH, DIAG);
                    /* re-enable interrupts */
	            PUT( walk->old_mcr ,MCR);
                }
	}
        if (!start_timer) mod_timer(&restart_timer,jiffies+IDT77105_RESTART_TIMER_PERIOD);
}


static int fetch_stats(struct atm_dev *dev,struct idt77105_stats __user *arg,int zero)
{
	unsigned long flags;
	struct idt77105_stats stats;

	spin_lock_irqsave(&idt77105_priv_lock, flags);
	memcpy(&stats, &PRIV(dev)->stats, sizeof(struct idt77105_stats));
	if (zero)
		memset(&PRIV(dev)->stats, 0, sizeof(struct idt77105_stats));
	spin_unlock_irqrestore(&idt77105_priv_lock, flags);
	if (arg == NULL)
		return 0;
	return copy_to_user(arg, &stats,
		    sizeof(struct idt77105_stats)) ? -EFAULT : 0;
}


static int set_loopback(struct atm_dev *dev,int mode)
{
	int diag;

	diag = GET(DIAG) & ~IDT77105_DIAG_LCMASK;
	switch (mode) {
		case ATM_LM_NONE:
			break;
		case ATM_LM_LOC_ATM:
			diag |= IDT77105_DIAG_LC_PHY_LOOPBACK;
			break;
		case ATM_LM_RMT_ATM:
			diag |= IDT77105_DIAG_LC_LINE_LOOPBACK;
			break;
		default:
			return -EINVAL;
	}
	PUT(diag,DIAG);
	printk(KERN_NOTICE "%s(%d) Loopback mode is: %s\n", dev->type,
	    dev->number,
	    (mode == ATM_LM_NONE ? "NONE" : 
	      (mode == ATM_LM_LOC_ATM ? "DIAG (local)" :
		(mode == IDT77105_DIAG_LC_LINE_LOOPBACK ? "LOOP (remote)" :
		  "unknown")))
		    );
	PRIV(dev)->loop_mode = mode;
	return 0;
}


static int idt77105_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
{
        printk(KERN_NOTICE "%s(%d) idt77105_ioctl() called\n",dev->type,dev->number);
	switch (cmd) {
		case IDT77105_GETSTATZ:
			if (!capable(CAP_NET_ADMIN)) return -EPERM;
			fallthrough;
		case IDT77105_GETSTAT:
			return fetch_stats(dev, arg, cmd == IDT77105_GETSTATZ);
		case ATM_SETLOOP:
			return set_loopback(dev,(int)(unsigned long) arg);
		case ATM_GETLOOP:
			return put_user(PRIV(dev)->loop_mode,(int __user *)arg) ?
			    -EFAULT : 0;
		case ATM_QUERYLOOP:
			return put_user(ATM_LM_LOC_ATM | ATM_LM_RMT_ATM,
			    (int __user *) arg) ? -EFAULT : 0;
		default:
			return -ENOIOCTLCMD;
	}
}


static void idt77105_int(struct atm_dev *dev)
{
        unsigned char istat;
        
        istat = GET(ISTAT); /* side effect: clears all interrupt status bits */
     
        DPRINTK("IDT77105 generated an interrupt, istat=%02x\n", (unsigned)istat);
                
        if (istat & IDT77105_ISTAT_RSCC) {
            /* Rx Signal Condition Change - line went up or down */
            if (istat & IDT77105_ISTAT_GOODSIG) {   /* signal detected again */
                /* This should not happen (restart timer does it) but JIC */
		atm_dev_signal_change(dev, ATM_PHY_SIG_FOUND);
            } else {    /* signal lost */
                /*
                 * Disable interrupts and stop all transmission and
                 * reception - the restart timer will restore these.
                 */
                PRIV(dev)->old_mcr = GET(MCR);
	        PUT(
                    (PRIV(dev)->old_mcr|
                    IDT77105_MCR_DREC|
                    IDT77105_MCR_DRIC|
                    IDT77105_MCR_HALTTX
                    ) & ~IDT77105_MCR_EIP, MCR);
		atm_dev_signal_change(dev, ATM_PHY_SIG_LOST);
	        printk(KERN_NOTICE "%s(itf %d): signal lost\n",
                    dev->type,dev->number);
            }
        }
        
        if (istat & IDT77105_ISTAT_RFO) {
            /* Rx FIFO Overrun -- perform a FIFO flush */
            PUT( GET(DIAG) | IDT77105_DIAG_RFLUSH, DIAG);
	    printk(KERN_NOTICE "%s(itf %d): receive FIFO overrun\n",
                dev->type,dev->number);
        }
#ifdef GENERAL_DEBUG
        if (istat & (IDT77105_ISTAT_HECERR | IDT77105_ISTAT_SCR |
                     IDT77105_ISTAT_RSE)) {
            /* normally don't care - just report in stats */
	    printk(KERN_NOTICE "%s(itf %d): received cell with error\n",
                dev->type,dev->number);
        }
#endif
}


static int idt77105_start(struct atm_dev *dev)
{
	unsigned long flags;

	if (!(dev->phy_data = kmalloc(sizeof(struct idt77105_priv),GFP_KERNEL)))
		return -ENOMEM;
	PRIV(dev)->dev = dev;
	spin_lock_irqsave(&idt77105_priv_lock, flags);
	PRIV(dev)->next = idt77105_all;
	idt77105_all = PRIV(dev);
	spin_unlock_irqrestore(&idt77105_priv_lock, flags);
	memset(&PRIV(dev)->stats,0,sizeof(struct idt77105_stats));
        
        /* initialise dev->signal from Good Signal Bit */
	atm_dev_signal_change(dev,
		GET(ISTAT) & IDT77105_ISTAT_GOODSIG ?
		ATM_PHY_SIG_FOUND : ATM_PHY_SIG_LOST);
	if (dev->signal == ATM_PHY_SIG_LOST)
		printk(KERN_WARNING "%s(itf %d): no signal\n",dev->type,
		    dev->number);

        /* initialise loop mode from hardware */
        switch ( GET(DIAG) & IDT77105_DIAG_LCMASK ) {
        case IDT77105_DIAG_LC_NORMAL:
            PRIV(dev)->loop_mode = ATM_LM_NONE;
            break;
        case IDT77105_DIAG_LC_PHY_LOOPBACK:
            PRIV(dev)->loop_mode = ATM_LM_LOC_ATM;
            break;
        case IDT77105_DIAG_LC_LINE_LOOPBACK:
            PRIV(dev)->loop_mode = ATM_LM_RMT_ATM;
            break;
        }
        
        /* enable interrupts, e.g. on loss of signal */
        PRIV(dev)->old_mcr = GET(MCR);
        if (dev->signal == ATM_PHY_SIG_FOUND) {
            PRIV(dev)->old_mcr |= IDT77105_MCR_EIP;
	    PUT(PRIV(dev)->old_mcr, MCR);
        }

                    
	idt77105_stats_timer_func(0); /* clear 77105 counters */
	(void) fetch_stats(dev,NULL,1); /* clear kernel counters */
        
	spin_lock_irqsave(&idt77105_priv_lock, flags);
	if (start_timer) {
		start_timer = 0;
                
		stats_timer.expires = jiffies+IDT77105_STATS_TIMER_PERIOD;
		add_timer(&stats_timer);
                
		restart_timer.expires = jiffies+IDT77105_RESTART_TIMER_PERIOD;
		add_timer(&restart_timer);
	}
	spin_unlock_irqrestore(&idt77105_priv_lock, flags);
	return 0;
}


static int idt77105_stop(struct atm_dev *dev)
{
	struct idt77105_priv *walk, *prev;

        DPRINTK("%s(itf %d): stopping IDT77105\n",dev->type,dev->number);
        
        /* disable interrupts */
	PUT( GET(MCR) & ~IDT77105_MCR_EIP, MCR );
        
        /* detach private struct from atm_dev & free */
	for (prev = NULL, walk = idt77105_all ;
             walk != NULL;
             prev = walk, walk = walk->next) {
            if (walk->dev == dev) {
                if (prev != NULL)
                    prev->next = walk->next;
                else
                    idt77105_all = walk->next;
	        dev->phy = NULL;
                dev->phy_data = NULL;
                kfree(walk);
                break;
            }
        }

	return 0;
}


static const struct atmphy_ops idt77105_ops = {
	.start = 	idt77105_start,
	.ioctl =	idt77105_ioctl,
	.interrupt =	idt77105_int,
	.stop =		idt77105_stop,
};


int idt77105_init(struct atm_dev *dev)
{
	dev->phy = &idt77105_ops;
	return 0;
}

EXPORT_SYMBOL(idt77105_init);

static void __exit idt77105_exit(void)
{
	/* turn off timers */
	del_timer_sync(&stats_timer);
	del_timer_sync(&restart_timer);
}

module_exit(idt77105_exit);

MODULE_DESCRIPTION("IDT77105 PHY driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
09c434b8	1	// SPDX-License-Identifier: GPL-2.0-only
1da177e4 LT	2	/* drivers/atm/idt77105.c - IDT77105 (PHY) driver */
	3
	4	/* Written 1999 by Greg Banks, NEC Australia <[email protected]>. Based on suni.c */
	5
	6
	7	#include <linux/module.h>
1da177e4 LT	8	#include <linux/kernel.h>
	9	#include <linux/mm.h>
	10	#include <linux/errno.h>
	11	#include <linux/atmdev.h>
	12	#include <linux/sonet.h>
	13	#include <linux/delay.h>
	14	#include <linux/timer.h>
	15	#include <linux/init.h>
	16	#include <linux/capability.h>
	17	#include <linux/atm_idt77105.h>
	18	#include <linux/spinlock.h>
5a0e3ad6	19	#include <linux/slab.h>
1da177e4	20	#include <asm/param.h>
7c0f6ba6	21	#include <linux/uaccess.h>
1da177e4 LT	22
	23	#include "idt77105.h"
	24
	25	#undef GENERAL_DEBUG
	26
	27	#ifdef GENERAL_DEBUG
	28	#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
	29	#else
	30	#define DPRINTK(format,args...)
	31	#endif
	32
	33
	34	struct idt77105_priv {
	35	struct idt77105_stats stats; /* link diagnostics */
	36	struct atm_dev dev; / device back-pointer */
	37	struct idt77105_priv *next;
	38	int loop_mode;
	39	unsigned char old_mcr; /* storage of MCR reg while signal lost */
	40	};
	41
	42	static DEFINE_SPINLOCK(idt77105_priv_lock);
	43
	44	#define PRIV(dev) ((struct idt77105_priv *) dev->phy_data)
	45
	46	#define PUT(val,reg) dev->ops->phy_put(dev,val,IDT77105_##reg)
	47	#define GET(reg) dev->ops->phy_get(dev,IDT77105_##reg)
	48
24ed960a KC	49	static void idt77105_stats_timer_func(struct timer_list *);
24ed960a KC	50	static void idt77105_restart_timer_func(struct timer_list *);
1da177e4 LT	51
1da177e4 LT	52
1d27e3e2 KC	53	static DEFINE_TIMER(stats_timer, idt77105_stats_timer_func);
1d27e3e2 KC	54	static DEFINE_TIMER(restart_timer, idt77105_restart_timer_func);
1da177e4 LT	55	static int start_timer = 1;
	56	static struct idt77105_priv *idt77105_all = NULL;
	57
	58	/*
	59	* Retrieve the value of one of the IDT77105's counters.
	60	* `counter' is one of the IDT77105_CTRSEL_* constants.
	61	*/
	62	static u16 get_counter(struct atm_dev *dev, int counter)
	63	{
	64	u16 val;
	65
	66	/* write the counter bit into PHY register 6 */
	67	PUT(counter, CTRSEL);
	68	/* read the low 8 bits from register 4 */
	69	val = GET(CTRLO);
	70	/* read the high 8 bits from register 5 */
	71	val \|= GET(CTRHI)<<8;
	72
	73	return val;
	74	}
	75
	76	/*
	77	* Timer function called every second to gather statistics
	78	* from the 77105. This is done because the h/w registers
	79	* will overflow if not read at least once per second. The
	80	* kernel's stats are much higher precision. Also, having
	81	* a separate copy of the stats allows implementation of
	82	* an ioctl which gathers the stats without zero'ing them.
	83	*/
24ed960a	84	static void idt77105_stats_timer_func(struct timer_list *unused)
1da177e4 LT	85	{
	86	struct idt77105_priv *walk;
	87	struct atm_dev *dev;
	88	struct idt77105_stats *stats;
	89
	90	DPRINTK("IDT77105 gathering statistics\n");
	91	for (walk = idt77105_all; walk; walk = walk->next) {
	92	dev = walk->dev;
	93
	94	stats = &walk->stats;
	95	stats->symbol_errors += get_counter(dev, IDT77105_CTRSEL_SEC);
	96	stats->tx_cells += get_counter(dev, IDT77105_CTRSEL_TCC);
	97	stats->rx_cells += get_counter(dev, IDT77105_CTRSEL_RCC);
	98	stats->rx_hec_errors += get_counter(dev, IDT77105_CTRSEL_RHEC);
	99	}
	100	if (!start_timer) mod_timer(&stats_timer,jiffies+IDT77105_STATS_TIMER_PERIOD);
	101	}
	102
	103
	104	/*
	105	* A separate timer func which handles restarting PHY chips which
	106	* have had the cable re-inserted after being pulled out. This is
	107	* done by polling the Good Signal Bit in the Interrupt Status
	108	* register every 5 seconds. The other technique (checking Good
	109	* Signal Bit in the interrupt handler) cannot be used because PHY
	110	* interrupts need to be disabled when the cable is pulled out
	111	* to avoid lots of spurious cell error interrupts.
	112	*/
24ed960a	113	static void idt77105_restart_timer_func(struct timer_list *unused)
1da177e4 LT	114	{
	115	struct idt77105_priv *walk;
	116	struct atm_dev *dev;
	117	unsigned char istat;
	118
	119	DPRINTK("IDT77105 checking for cable re-insertion\n");
	120	for (walk = idt77105_all; walk; walk = walk->next) {
	121	dev = walk->dev;
	122
	123	if (dev->signal != ATM_PHY_SIG_LOST)
	124	continue;
	125
	126	istat = GET(ISTAT); /* side effect: clears all interrupt status bits */
	127	if (istat & IDT77105_ISTAT_GOODSIG) {
	128	/* Found signal again */
07534553	129	atm_dev_signal_change(dev, ATM_PHY_SIG_FOUND);
1da177e4 LT	130	printk(KERN_NOTICE "%s(itf %d): signal detected again\n",
	131	dev->type,dev->number);
	132	/* flush the receive FIFO */
	133	PUT( GET(DIAG) \| IDT77105_DIAG_RFLUSH, DIAG);
	134	/* re-enable interrupts */
	135	PUT( walk->old_mcr ,MCR);
	136	}
	137	}
	138	if (!start_timer) mod_timer(&restart_timer,jiffies+IDT77105_RESTART_TIMER_PERIOD);
	139	}
	140
	141
	142	static int fetch_stats(struct atm_dev dev,struct idt77105_stats __user arg,int zero)
	143	{
	144	unsigned long flags;
	145	struct idt77105_stats stats;
	146
	147	spin_lock_irqsave(&idt77105_priv_lock, flags);
	148	memcpy(&stats, &PRIV(dev)->stats, sizeof(struct idt77105_stats));
	149	if (zero)
	150	memset(&PRIV(dev)->stats, 0, sizeof(struct idt77105_stats));
	151	spin_unlock_irqrestore(&idt77105_priv_lock, flags);
	152	if (arg == NULL)
	153	return 0;
2221eca0	154	return copy_to_user(arg, &stats,
1da177e4 LT	155	sizeof(struct idt77105_stats)) ? -EFAULT : 0;
	156	}
	157
	158
	159	static int set_loopback(struct atm_dev *dev,int mode)
	160	{
	161	int diag;
	162
	163	diag = GET(DIAG) & ~IDT77105_DIAG_LCMASK;
	164	switch (mode) {
	165	case ATM_LM_NONE:
	166	break;
	167	case ATM_LM_LOC_ATM:
	168	diag \|= IDT77105_DIAG_LC_PHY_LOOPBACK;
	169	break;
	170	case ATM_LM_RMT_ATM:
	171	diag \|= IDT77105_DIAG_LC_LINE_LOOPBACK;
	172	break;
	173	default:
	174	return -EINVAL;
	175	}
	176	PUT(diag,DIAG);
	177	printk(KERN_NOTICE "%s(%d) Loopback mode is: %s\n", dev->type,
	178	dev->number,
	179	(mode == ATM_LM_NONE ? "NONE" :
	180	(mode == ATM_LM_LOC_ATM ? "DIAG (local)" :
	181	(mode == IDT77105_DIAG_LC_LINE_LOOPBACK ? "LOOP (remote)" :
	182	"unknown")))
	183	);
	184	PRIV(dev)->loop_mode = mode;
	185	return 0;
	186	}
	187
	188
	189	static int idt77105_ioctl(struct atm_dev dev,unsigned int cmd,void __user arg)
	190	{
	191	printk(KERN_NOTICE "%s(%d) idt77105_ioctl() called\n",dev->type,dev->number);
	192	switch (cmd) {
	193	case IDT77105_GETSTATZ:
	194	if (!capable(CAP_NET_ADMIN)) return -EPERM;
df561f66	195	fallthrough;
1da177e4 LT	196	case IDT77105_GETSTAT:
	197	return fetch_stats(dev, arg, cmd == IDT77105_GETSTATZ);
	198	case ATM_SETLOOP:
	199	return set_loopback(dev,(int)(unsigned long) arg);
	200	case ATM_GETLOOP:
	201	return put_user(PRIV(dev)->loop_mode,(int __user *)arg) ?
	202	-EFAULT : 0;
	203	case ATM_QUERYLOOP:
	204	return put_user(ATM_LM_LOC_ATM \| ATM_LM_RMT_ATM,
	205	(int __user *) arg) ? -EFAULT : 0;
	206	default:
	207	return -ENOIOCTLCMD;
	208	}
	209	}
	210
	211
	212
	213	static void idt77105_int(struct atm_dev *dev)
	214	{
	215	unsigned char istat;
	216
	217	istat = GET(ISTAT); /* side effect: clears all interrupt status bits */
	218
	219	DPRINTK("IDT77105 generated an interrupt, istat=%02x\n", (unsigned)istat);
	220
	221	if (istat & IDT77105_ISTAT_RSCC) {
	222	/* Rx Signal Condition Change - line went up or down */
	223	if (istat & IDT77105_ISTAT_GOODSIG) { /* signal detected again */
	224	/* This should not happen (restart timer does it) but JIC */
07534553	225	atm_dev_signal_change(dev, ATM_PHY_SIG_FOUND);
1da177e4 LT	226	} else { /* signal lost */
	227	/*
	228	* Disable interrupts and stop all transmission and
	229	* reception - the restart timer will restore these.
	230	*/
	231	PRIV(dev)->old_mcr = GET(MCR);
	232	PUT(
	233	(PRIV(dev)->old_mcr\|
	234	IDT77105_MCR_DREC\|
	235	IDT77105_MCR_DRIC\|
	236	IDT77105_MCR_HALTTX
	237	) & ~IDT77105_MCR_EIP, MCR);
07534553	238	atm_dev_signal_change(dev, ATM_PHY_SIG_LOST);
1da177e4 LT	239	printk(KERN_NOTICE "%s(itf %d): signal lost\n",
	240	dev->type,dev->number);
	241	}
	242	}
	243
	244	if (istat & IDT77105_ISTAT_RFO) {
	245	/* Rx FIFO Overrun -- perform a FIFO flush */
	246	PUT( GET(DIAG) \| IDT77105_DIAG_RFLUSH, DIAG);
	247	printk(KERN_NOTICE "%s(itf %d): receive FIFO overrun\n",
	248	dev->type,dev->number);
	249	}
	250	#ifdef GENERAL_DEBUG
	251	if (istat & (IDT77105_ISTAT_HECERR \| IDT77105_ISTAT_SCR \|
	252	IDT77105_ISTAT_RSE)) {
	253	/* normally don't care - just report in stats */
	254	printk(KERN_NOTICE "%s(itf %d): received cell with error\n",
	255	dev->type,dev->number);
	256	}
	257	#endif
	258	}
	259
	260
	261	static int idt77105_start(struct atm_dev *dev)
	262	{
	263	unsigned long flags;
	264
4416e985	265	if (!(dev->phy_data = kmalloc(sizeof(struct idt77105_priv),GFP_KERNEL)))
1da177e4 LT	266	return -ENOMEM;
	267	PRIV(dev)->dev = dev;
	268	spin_lock_irqsave(&idt77105_priv_lock, flags);
	269	PRIV(dev)->next = idt77105_all;
	270	idt77105_all = PRIV(dev);
	271	spin_unlock_irqrestore(&idt77105_priv_lock, flags);
	272	memset(&PRIV(dev)->stats,0,sizeof(struct idt77105_stats));
	273
	274	/* initialise dev->signal from Good Signal Bit */
07534553 KH	275	atm_dev_signal_change(dev,
	276	GET(ISTAT) & IDT77105_ISTAT_GOODSIG ?
	277	ATM_PHY_SIG_FOUND : ATM_PHY_SIG_LOST);
1da177e4 LT	278	if (dev->signal == ATM_PHY_SIG_LOST)
	279	printk(KERN_WARNING "%s(itf %d): no signal\n",dev->type,
	280	dev->number);
	281
	282	/* initialise loop mode from hardware */
	283	switch ( GET(DIAG) & IDT77105_DIAG_LCMASK ) {
	284	case IDT77105_DIAG_LC_NORMAL:
	285	PRIV(dev)->loop_mode = ATM_LM_NONE;
	286	break;
	287	case IDT77105_DIAG_LC_PHY_LOOPBACK:
	288	PRIV(dev)->loop_mode = ATM_LM_LOC_ATM;
	289	break;
	290	case IDT77105_DIAG_LC_LINE_LOOPBACK:
	291	PRIV(dev)->loop_mode = ATM_LM_RMT_ATM;
	292	break;
	293	}
	294
	295	/* enable interrupts, e.g. on loss of signal */
	296	PRIV(dev)->old_mcr = GET(MCR);
	297	if (dev->signal == ATM_PHY_SIG_FOUND) {
	298	PRIV(dev)->old_mcr \|= IDT77105_MCR_EIP;
	299	PUT(PRIV(dev)->old_mcr, MCR);
	300	}
	301
	302
	303	idt77105_stats_timer_func(0); /* clear 77105 counters */
	304	(void) fetch_stats(dev,NULL,1); /* clear kernel counters */
	305
	306	spin_lock_irqsave(&idt77105_priv_lock, flags);
	307	if (start_timer) {
	308	start_timer = 0;
	309
1da177e4	310	stats_timer.expires = jiffies+IDT77105_STATS_TIMER_PERIOD;
1da177e4 LT	311	add_timer(&stats_timer);
1da177e4 LT	312
1da177e4	313	restart_timer.expires = jiffies+IDT77105_RESTART_TIMER_PERIOD;
1da177e4 LT	314	add_timer(&restart_timer);
	315	}
	316	spin_unlock_irqrestore(&idt77105_priv_lock, flags);
	317	return 0;
	318	}
	319
	320
	321	static int idt77105_stop(struct atm_dev *dev)
	322	{
	323	struct idt77105_priv walk, prev;
	324
	325	DPRINTK("%s(itf %d): stopping IDT77105\n",dev->type,dev->number);
	326
	327	/* disable interrupts */
	328	PUT( GET(MCR) & ~IDT77105_MCR_EIP, MCR );
	329
	330	/* detach private struct from atm_dev & free */
	331	for (prev = NULL, walk = idt77105_all ;
	332	walk != NULL;
	333	prev = walk, walk = walk->next) {
	334	if (walk->dev == dev) {
	335	if (prev != NULL)
	336	prev->next = walk->next;
	337	else
	338	idt77105_all = walk->next;
	339	dev->phy = NULL;
4416e985	340	dev->phy_data = NULL;
1da177e4 LT	341	kfree(walk);
	342	break;
	343	}
	344	}
	345
	346	return 0;
	347	}
	348
	349
	350	static const struct atmphy_ops idt77105_ops = {
	351	.start = idt77105_start,
	352	.ioctl = idt77105_ioctl,
	353	.interrupt = idt77105_int,
	354	.stop = idt77105_stop,
	355	};
	356
	357
799fa677	358	int idt77105_init(struct atm_dev *dev)
1da177e4 LT	359	{
	360	dev->phy = &idt77105_ops;
	361	return 0;
	362	}
	363
	364	EXPORT_SYMBOL(idt77105_init);
	365
	366	static void __exit idt77105_exit(void)
	367	{
869f2739 TG	368	/* turn off timers */
	369	del_timer_sync(&stats_timer);
	370	del_timer_sync(&restart_timer);
1da177e4 LT	371	}
	372
	373	module_exit(idt77105_exit);
	374
fc0caed8	375	MODULE_DESCRIPTION("IDT77105 PHY driver");
1da177e4	376	MODULE_LICENSE("GPL");