[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / atm / suni.c

/*
 * drivers/atm/suni.c - S/UNI PHY driver
 *
 * Supports the following:
 * 	PMC PM5346 S/UNI LITE
 * 	PMC PM5350 S/UNI 155 ULTRA
 * 	PMC PM5355 S/UNI 622
 */
 
/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */

#include <linux/module.h>
#include <linux/jiffies.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_suni.h>
#include <linux/slab.h>
#include <asm/param.h>
#include <asm/uaccess.h>
#include <linux/atomic.h>

#include "suni.h"


#if 0
#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
#else
#define DPRINTK(format,args...)
#endif

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

#define PUT(val,reg) dev->ops->phy_put(dev,val,SUNI_##reg)
#define GET(reg) dev->ops->phy_get(dev,SUNI_##reg)
#define REG_CHANGE(mask,shift,value,reg) \
  PUT((GET(reg) & ~(mask)) | ((value) << (shift)),reg)


static struct timer_list poll_timer;
static struct suni_priv *sunis = NULL;
static DEFINE_SPINLOCK(sunis_lock);


#define ADD_LIMITED(s,v) \
    atomic_add((v),&stats->s); \
    if (atomic_read(&stats->s) < 0) atomic_set(&stats->s,INT_MAX);


static void suni_hz(unsigned long from_timer)
{
	struct suni_priv *walk;
	struct atm_dev *dev;
	struct k_sonet_stats *stats;

	for (walk = sunis; walk; walk = walk->next) {
		dev = walk->dev;
		stats = &walk->sonet_stats;
		PUT(0,MRI); /* latch counters */
		udelay(1);
		ADD_LIMITED(section_bip,(GET(RSOP_SBL) & 0xff) |
		    ((GET(RSOP_SBM) & 0xff) << 8));
		ADD_LIMITED(line_bip,(GET(RLOP_LBL) & 0xff) |
		    ((GET(RLOP_LB) & 0xff) << 8) |
		    ((GET(RLOP_LBM) & 0xf) << 16));
		ADD_LIMITED(path_bip,(GET(RPOP_PBL) & 0xff) |
		    ((GET(RPOP_PBM) & 0xff) << 8));
		ADD_LIMITED(line_febe,(GET(RLOP_LFL) & 0xff) |
		    ((GET(RLOP_LF) & 0xff) << 8) |
		    ((GET(RLOP_LFM) & 0xf) << 16));
		ADD_LIMITED(path_febe,(GET(RPOP_PFL) & 0xff) |
		    ((GET(RPOP_PFM) & 0xff) << 8));
		ADD_LIMITED(corr_hcs,GET(RACP_CHEC) & 0xff);
		ADD_LIMITED(uncorr_hcs,GET(RACP_UHEC) & 0xff);
		ADD_LIMITED(rx_cells,(GET(RACP_RCCL) & 0xff) |
		    ((GET(RACP_RCC) & 0xff) << 8) |
		    ((GET(RACP_RCCM) & 7) << 16));
		ADD_LIMITED(tx_cells,(GET(TACP_TCCL) & 0xff) |
		    ((GET(TACP_TCC) & 0xff) << 8) |
		    ((GET(TACP_TCCM) & 7) << 16));
	}
	if (from_timer) mod_timer(&poll_timer,jiffies+HZ);
}


#undef ADD_LIMITED


static int fetch_stats(struct atm_dev *dev,struct sonet_stats __user *arg,int zero)
{
	struct sonet_stats tmp;
	int error = 0;

	sonet_copy_stats(&PRIV(dev)->sonet_stats,&tmp);
	if (arg) error = copy_to_user(arg,&tmp,sizeof(tmp));
	if (zero && !error) sonet_subtract_stats(&PRIV(dev)->sonet_stats,&tmp);
	return error ? -EFAULT : 0;
}


#define HANDLE_FLAG(flag,reg,bit) \
  if (todo & flag) { \
    if (set) PUT(GET(reg) | bit,reg); \
    else PUT(GET(reg) & ~bit,reg); \
    todo &= ~flag; \
  }


static int change_diag(struct atm_dev *dev,void __user *arg,int set)
{
	int todo;

	if (get_user(todo,(int __user *)arg)) return -EFAULT;
	HANDLE_FLAG(SONET_INS_SBIP,TSOP_DIAG,SUNI_TSOP_DIAG_DBIP8);
	HANDLE_FLAG(SONET_INS_LBIP,TLOP_DIAG,SUNI_TLOP_DIAG_DBIP);
	HANDLE_FLAG(SONET_INS_PBIP,TPOP_CD,SUNI_TPOP_DIAG_DB3);
	HANDLE_FLAG(SONET_INS_FRAME,RSOP_CIE,SUNI_RSOP_CIE_FOOF);
	HANDLE_FLAG(SONET_INS_LAIS,TSOP_CTRL,SUNI_TSOP_CTRL_LAIS);
	HANDLE_FLAG(SONET_INS_PAIS,TPOP_CD,SUNI_TPOP_DIAG_PAIS);
	HANDLE_FLAG(SONET_INS_LOS,TSOP_DIAG,SUNI_TSOP_DIAG_DLOS);
	HANDLE_FLAG(SONET_INS_HCS,TACP_CS,SUNI_TACP_CS_DHCS);
	return put_user(todo,(int __user *)arg) ? -EFAULT : 0;
}


#undef HANDLE_FLAG


static int get_diag(struct atm_dev *dev,void __user *arg)
{
	int set;

	set = 0;
	if (GET(TSOP_DIAG) & SUNI_TSOP_DIAG_DBIP8) set |= SONET_INS_SBIP;
	if (GET(TLOP_DIAG) & SUNI_TLOP_DIAG_DBIP) set |= SONET_INS_LBIP;
	if (GET(TPOP_CD) & SUNI_TPOP_DIAG_DB3) set |= SONET_INS_PBIP;
	/* SONET_INS_FRAME is one-shot only */
	if (GET(TSOP_CTRL) & SUNI_TSOP_CTRL_LAIS) set |= SONET_INS_LAIS;
	if (GET(TPOP_CD) & SUNI_TPOP_DIAG_PAIS) set |= SONET_INS_PAIS;
	if (GET(TSOP_DIAG) & SUNI_TSOP_DIAG_DLOS) set |= SONET_INS_LOS;
	if (GET(TACP_CS) & SUNI_TACP_CS_DHCS) set |= SONET_INS_HCS;
	return put_user(set,(int __user *)arg) ? -EFAULT : 0;
}


static int set_loopback(struct atm_dev *dev,int mode)
{
	unsigned char control;
	int reg, dle, lle;

	if (PRIV(dev)->type == SUNI_MRI_TYPE_PM5355) {
		reg = SUNI_MCM;
		dle = SUNI_MCM_DLE;
		lle = SUNI_MCM_LLE;
	} else {
		reg = SUNI_MCT;
		dle = SUNI_MCT_DLE;
		lle = SUNI_MCT_LLE;
	}

	control = dev->ops->phy_get(dev, reg) & ~(dle | lle);
	switch (mode) {
		case ATM_LM_NONE:
			break;
		case ATM_LM_LOC_PHY:
			control |= dle;
			break;
		case ATM_LM_RMT_PHY:
			control |= lle;
			break;
		default:
			return -EINVAL;
	}
	 dev->ops->phy_put(dev, control, reg);
	PRIV(dev)->loop_mode = mode;
	return 0;
}

/*
 * SONET vs. SDH Configuration
 *
 * Z0INS (register 0x06): 0 for SONET, 1 for SDH
 * ENSS (register 0x3D): 0 for SONET, 1 for SDH
 * LEN16 (register 0x28): 0 for SONET, 1 for SDH (n/a for S/UNI 155 QUAD)
 * LEN16 (register 0x50): 0 for SONET, 1 for SDH (n/a for S/UNI 155 QUAD)
 * S[1:0] (register 0x46): 00 for SONET, 10 for SDH
 */

static int set_sonet(struct atm_dev *dev)
{
	if (PRIV(dev)->type == SUNI_MRI_TYPE_PM5355) {
		PUT(GET(RPOP_RC) & ~SUNI_RPOP_RC_ENSS, RPOP_RC);
		PUT(GET(SSTB_CTRL) & ~SUNI_SSTB_CTRL_LEN16, SSTB_CTRL);
		PUT(GET(SPTB_CTRL) & ~SUNI_SPTB_CTRL_LEN16, SPTB_CTRL);
	}

	REG_CHANGE(SUNI_TPOP_APM_S, SUNI_TPOP_APM_S_SHIFT,
		   SUNI_TPOP_S_SONET, TPOP_APM);

	return 0;
}

static int set_sdh(struct atm_dev *dev)
{
	if (PRIV(dev)->type == SUNI_MRI_TYPE_PM5355) {
		PUT(GET(RPOP_RC) | SUNI_RPOP_RC_ENSS, RPOP_RC);
		PUT(GET(SSTB_CTRL) | SUNI_SSTB_CTRL_LEN16, SSTB_CTRL);
		PUT(GET(SPTB_CTRL) | SUNI_SPTB_CTRL_LEN16, SPTB_CTRL);
	}

	REG_CHANGE(SUNI_TPOP_APM_S, SUNI_TPOP_APM_S_SHIFT,
		   SUNI_TPOP_S_SDH, TPOP_APM);

	return 0;
}


static int get_framing(struct atm_dev *dev, void __user *arg)
{
	int framing;
	unsigned char s;


	s = (GET(TPOP_APM) & SUNI_TPOP_APM_S) >> SUNI_TPOP_APM_S_SHIFT;
	if (s == SUNI_TPOP_S_SONET)
		framing = SONET_FRAME_SONET;
	else
		framing = SONET_FRAME_SDH;

	return put_user(framing, (int __user *) arg) ? -EFAULT : 0;
}

static int set_framing(struct atm_dev *dev, void __user *arg)
{
	int mode;

	if (get_user(mode, (int __user *) arg))
		return -EFAULT;

	if (mode == SONET_FRAME_SONET)
		return set_sonet(dev);
	else if (mode == SONET_FRAME_SDH)
		return set_sdh(dev);

	return -EINVAL;
}


static int suni_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
{
	switch (cmd) {
		case SONET_GETSTATZ:
		case SONET_GETSTAT:
			return fetch_stats(dev, arg, cmd == SONET_GETSTATZ);
		case SONET_SETDIAG:
			return change_diag(dev,arg,1);
		case SONET_CLRDIAG:
			return change_diag(dev,arg,0);
		case SONET_GETDIAG:
			return get_diag(dev,arg);
		case SONET_SETFRAMING:
			if (!capable(CAP_NET_ADMIN))
				return -EPERM;
			return set_framing(dev, arg);
		case SONET_GETFRAMING:
			return get_framing(dev, arg);
		case SONET_GETFRSENSE:
			return -EINVAL;
		case ATM_SETLOOP:
			if (!capable(CAP_NET_ADMIN))
				return -EPERM;
			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_PHY | ATM_LM_RMT_PHY,
			    (int __user *) arg) ? -EFAULT : 0;
		default:
			return -ENOIOCTLCMD;
	}
}


static void poll_los(struct atm_dev *dev)
{
	atm_dev_signal_change(dev,
		GET(RSOP_SIS) & SUNI_RSOP_SIS_LOSV ?
		ATM_PHY_SIG_LOST : ATM_PHY_SIG_FOUND);
}


static void suni_int(struct atm_dev *dev)
{
	poll_los(dev);
	printk(KERN_NOTICE "%s(itf %d): signal %s\n",dev->type,dev->number,
	    dev->signal == ATM_PHY_SIG_LOST ?  "lost" : "detected again");
}


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

	spin_lock_irqsave(&sunis_lock,flags);
	first = !sunis;
	PRIV(dev)->next = sunis;
	sunis = PRIV(dev);
	spin_unlock_irqrestore(&sunis_lock,flags);
	memset(&PRIV(dev)->sonet_stats,0,sizeof(struct k_sonet_stats));
	PUT(GET(RSOP_CIE) | SUNI_RSOP_CIE_LOSE,RSOP_CIE);
		/* interrupt on loss of signal */
	poll_los(dev); /* ... and clear SUNI interrupts */
	if (dev->signal == ATM_PHY_SIG_LOST)
		printk(KERN_WARNING "%s(itf %d): no signal\n",dev->type,
		    dev->number);
	PRIV(dev)->loop_mode = ATM_LM_NONE;
	suni_hz(0); /* clear SUNI counters */
	(void) fetch_stats(dev,NULL,1); /* clear kernel counters */
	if (first) {
		init_timer(&poll_timer);
		poll_timer.expires = jiffies+HZ;
		poll_timer.function = suni_hz;
		poll_timer.data = 1;
#if 0
printk(KERN_DEBUG "[u] p=0x%lx,n=0x%lx\n",(unsigned long) poll_timer.list.prev,
    (unsigned long) poll_timer.list.next);
#endif
		add_timer(&poll_timer);
	}
	return 0;
}


static int suni_stop(struct atm_dev *dev)
{
	struct suni_priv **walk;
	unsigned long flags;

	/* let SAR driver worry about stopping interrupts */
	spin_lock_irqsave(&sunis_lock,flags);
	for (walk = &sunis; *walk != PRIV(dev);
	    walk = &PRIV((*walk)->dev)->next);
	*walk = PRIV((*walk)->dev)->next;
	if (!sunis) del_timer_sync(&poll_timer);
	spin_unlock_irqrestore(&sunis_lock,flags);
	kfree(PRIV(dev));

	return 0;
}


static const struct atmphy_ops suni_ops = {
	.start		= suni_start,
	.ioctl		= suni_ioctl,
	.interrupt	= suni_int,
	.stop		= suni_stop,
};


int suni_init(struct atm_dev *dev)
{
	unsigned char mri;

	if (!(dev->phy_data = kmalloc(sizeof(struct suni_priv),GFP_KERNEL)))
		return -ENOMEM;
	PRIV(dev)->dev = dev;

	mri = GET(MRI); /* reset SUNI */
	PRIV(dev)->type = (mri & SUNI_MRI_TYPE) >> SUNI_MRI_TYPE_SHIFT;
	PUT(mri | SUNI_MRI_RESET,MRI);
	PUT(mri,MRI);
	PUT((GET(MT) & SUNI_MT_DS27_53),MT); /* disable all tests */
        set_sonet(dev);
	REG_CHANGE(SUNI_TACP_IUCHP_CLP,0,SUNI_TACP_IUCHP_CLP,
	    TACP_IUCHP); /* idle cells */
	PUT(SUNI_IDLE_PATTERN,TACP_IUCPOP);
	dev->phy = &suni_ops;

	return 0;
}

EXPORT_SYMBOL(suni_init);

MODULE_LICENSE("GPL");
Commit	Line	Data
df3bc8bd CW	1	/*
	2	* drivers/atm/suni.c - S/UNI PHY driver
	3	*
	4	* Supports the following:
	5	* PMC PM5346 S/UNI LITE
	6	* PMC PM5350 S/UNI 155 ULTRA
	7	* PMC PM5355 S/UNI 622
	8	*/
1da177e4 LT	9
	10	/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
	11
1da177e4 LT	12	#include <linux/module.h>
	13	#include <linux/jiffies.h>
	14	#include <linux/kernel.h>
	15	#include <linux/mm.h>
	16	#include <linux/errno.h>
	17	#include <linux/atmdev.h>
	18	#include <linux/sonet.h>
	19	#include <linux/delay.h>
	20	#include <linux/timer.h>
	21	#include <linux/init.h>
	22	#include <linux/capability.h>
	23	#include <linux/atm_suni.h>
5a0e3ad6	24	#include <linux/slab.h>
1da177e4 LT	25	#include <asm/param.h>
1da177e4 LT	26	#include <asm/uaccess.h>
60063497	27	#include <linux/atomic.h>
1da177e4 LT	28
	29	#include "suni.h"
	30
	31
	32	#if 0
	33	#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
	34	#else
	35	#define DPRINTK(format,args...)
	36	#endif
	37
1da177e4 LT	38	#define PRIV(dev) ((struct suni_priv *) dev->phy_data)
	39
	40	#define PUT(val,reg) dev->ops->phy_put(dev,val,SUNI_##reg)
	41	#define GET(reg) dev->ops->phy_get(dev,SUNI_##reg)
	42	#define REG_CHANGE(mask,shift,value,reg) \
	43	PUT((GET(reg) & ~(mask)) \| ((value) << (shift)),reg)
	44
	45
	46	static struct timer_list poll_timer;
	47	static struct suni_priv *sunis = NULL;
	48	static DEFINE_SPINLOCK(sunis_lock);
	49
	50
	51	#define ADD_LIMITED(s,v) \
	52	atomic_add((v),&stats->s); \
	53	if (atomic_read(&stats->s) < 0) atomic_set(&stats->s,INT_MAX);
	54
	55
	56	static void suni_hz(unsigned long from_timer)
	57	{
	58	struct suni_priv *walk;
	59	struct atm_dev *dev;
	60	struct k_sonet_stats *stats;
	61
	62	for (walk = sunis; walk; walk = walk->next) {
	63	dev = walk->dev;
	64	stats = &walk->sonet_stats;
	65	PUT(0,MRI); /* latch counters */
	66	udelay(1);
	67	ADD_LIMITED(section_bip,(GET(RSOP_SBL) & 0xff) \|
	68	((GET(RSOP_SBM) & 0xff) << 8));
	69	ADD_LIMITED(line_bip,(GET(RLOP_LBL) & 0xff) \|
	70	((GET(RLOP_LB) & 0xff) << 8) \|
	71	((GET(RLOP_LBM) & 0xf) << 16));
	72	ADD_LIMITED(path_bip,(GET(RPOP_PBL) & 0xff) \|
	73	((GET(RPOP_PBM) & 0xff) << 8));
	74	ADD_LIMITED(line_febe,(GET(RLOP_LFL) & 0xff) \|
	75	((GET(RLOP_LF) & 0xff) << 8) \|
	76	((GET(RLOP_LFM) & 0xf) << 16));
	77	ADD_LIMITED(path_febe,(GET(RPOP_PFL) & 0xff) \|
	78	((GET(RPOP_PFM) & 0xff) << 8));
	79	ADD_LIMITED(corr_hcs,GET(RACP_CHEC) & 0xff);
	80	ADD_LIMITED(uncorr_hcs,GET(RACP_UHEC) & 0xff);
	81	ADD_LIMITED(rx_cells,(GET(RACP_RCCL) & 0xff) \|
	82	((GET(RACP_RCC) & 0xff) << 8) \|
	83	((GET(RACP_RCCM) & 7) << 16));
	84	ADD_LIMITED(tx_cells,(GET(TACP_TCCL) & 0xff) \|
	85	((GET(TACP_TCC) & 0xff) << 8) \|
	86	((GET(TACP_TCCM) & 7) << 16));
	87	}
	88	if (from_timer) mod_timer(&poll_timer,jiffies+HZ);
	89	}
	90
	91
	92	#undef ADD_LIMITED
	93
	94
	95	static int fetch_stats(struct atm_dev dev,struct sonet_stats __user arg,int zero)
	96	{
	97	struct sonet_stats tmp;
	98	int error = 0;
	99
	100	sonet_copy_stats(&PRIV(dev)->sonet_stats,&tmp);
	101	if (arg) error = copy_to_user(arg,&tmp,sizeof(tmp));
102	if (zero && !error) sonet_subtract_stats(&PRIV(dev)->sonet_stats,&tmp);
103	return error ? -EFAULT : 0;
104	}
105
106
107	#define HANDLE_FLAG(flag,reg,bit) \
108	if (todo & flag) { \
109	if (set) PUT(GET(reg) \| bit,reg); \
110	else PUT(GET(reg) & ~bit,reg); \
111	todo &= ~flag; \
112	}
113
114
115	static int change_diag(struct atm_dev dev,void __user arg,int set)
116	{
117	int todo;
118
119	if (get_user(todo,(int __user *)arg)) return -EFAULT;
120	HANDLE_FLAG(SONET_INS_SBIP,TSOP_DIAG,SUNI_TSOP_DIAG_DBIP8);
121	HANDLE_FLAG(SONET_INS_LBIP,TLOP_DIAG,SUNI_TLOP_DIAG_DBIP);
122	HANDLE_FLAG(SONET_INS_PBIP,TPOP_CD,SUNI_TPOP_DIAG_DB3);
123	HANDLE_FLAG(SONET_INS_FRAME,RSOP_CIE,SUNI_RSOP_CIE_FOOF);
124	HANDLE_FLAG(SONET_INS_LAIS,TSOP_CTRL,SUNI_TSOP_CTRL_LAIS);
125	HANDLE_FLAG(SONET_INS_PAIS,TPOP_CD,SUNI_TPOP_DIAG_PAIS);
126	HANDLE_FLAG(SONET_INS_LOS,TSOP_DIAG,SUNI_TSOP_DIAG_DLOS);
127	HANDLE_FLAG(SONET_INS_HCS,TACP_CS,SUNI_TACP_CS_DHCS);
128	return put_user(todo,(int __user *)arg) ? -EFAULT : 0;
129	}
130
131
132	#undef HANDLE_FLAG
133
134
135	static int get_diag(struct atm_dev dev,void __user arg)
136	{
137	int set;
138
139	set = 0;
140	if (GET(TSOP_DIAG) & SUNI_TSOP_DIAG_DBIP8) set \|= SONET_INS_SBIP;
141	if (GET(TLOP_DIAG) & SUNI_TLOP_DIAG_DBIP) set \|= SONET_INS_LBIP;
142	if (GET(TPOP_CD) & SUNI_TPOP_DIAG_DB3) set \|= SONET_INS_PBIP;
143	/* SONET_INS_FRAME is one-shot only */
144	if (GET(TSOP_CTRL) & SUNI_TSOP_CTRL_LAIS) set \|= SONET_INS_LAIS;
145	if (GET(TPOP_CD) & SUNI_TPOP_DIAG_PAIS) set \|= SONET_INS_PAIS;
146	if (GET(TSOP_DIAG) & SUNI_TSOP_DIAG_DLOS) set \|= SONET_INS_LOS;
147	if (GET(TACP_CS) & SUNI_TACP_CS_DHCS) set \|= SONET_INS_HCS;
148	return put_user(set,(int __user *)arg) ? -EFAULT : 0;
149	}
150
151
152	static int set_loopback(struct atm_dev *dev,int mode)
153	{
154	unsigned char control;
df3bc8bd CW	155	int reg, dle, lle;
	156
	157	if (PRIV(dev)->type == SUNI_MRI_TYPE_PM5355) {
	158	reg = SUNI_MCM;
	159	dle = SUNI_MCM_DLE;
	160	lle = SUNI_MCM_LLE;
	161	} else {
	162	reg = SUNI_MCT;
	163	dle = SUNI_MCT_DLE;
	164	lle = SUNI_MCT_LLE;
	165	}
1da177e4	166
df3bc8bd	167	control = dev->ops->phy_get(dev, reg) & ~(dle \| lle);
1da177e4 LT	168	switch (mode) {
	169	case ATM_LM_NONE:
	170	break;
	171	case ATM_LM_LOC_PHY:
df3bc8bd	172	control \|= dle;
1da177e4 LT	173	break;
1da177e4 LT	174	case ATM_LM_RMT_PHY:
df3bc8bd	175	control \|= lle;
1da177e4 LT	176	break;
	177	default:
	178	return -EINVAL;
	179	}
df3bc8bd	180	dev->ops->phy_put(dev, control, reg);
1da177e4 LT	181	PRIV(dev)->loop_mode = mode;
	182	return 0;
	183	}
	184
df3bc8bd CW	185	/*
	186	* SONET vs. SDH Configuration
	187	*
	188	* Z0INS (register 0x06): 0 for SONET, 1 for SDH
	189	* ENSS (register 0x3D): 0 for SONET, 1 for SDH
	190	* LEN16 (register 0x28): 0 for SONET, 1 for SDH (n/a for S/UNI 155 QUAD)
	191	* LEN16 (register 0x50): 0 for SONET, 1 for SDH (n/a for S/UNI 155 QUAD)
	192	* S[1:0] (register 0x46): 00 for SONET, 10 for SDH
	193	*/
	194
	195	static int set_sonet(struct atm_dev *dev)
	196	{
	197	if (PRIV(dev)->type == SUNI_MRI_TYPE_PM5355) {
	198	PUT(GET(RPOP_RC) & ~SUNI_RPOP_RC_ENSS, RPOP_RC);
	199	PUT(GET(SSTB_CTRL) & ~SUNI_SSTB_CTRL_LEN16, SSTB_CTRL);
	200	PUT(GET(SPTB_CTRL) & ~SUNI_SPTB_CTRL_LEN16, SPTB_CTRL);
	201	}
	202
	203	REG_CHANGE(SUNI_TPOP_APM_S, SUNI_TPOP_APM_S_SHIFT,
	204	SUNI_TPOP_S_SONET, TPOP_APM);
	205
	206	return 0;
	207	}
	208
	209	static int set_sdh(struct atm_dev *dev)
	210	{
	211	if (PRIV(dev)->type == SUNI_MRI_TYPE_PM5355) {
	212	PUT(GET(RPOP_RC) \| SUNI_RPOP_RC_ENSS, RPOP_RC);
	213	PUT(GET(SSTB_CTRL) \| SUNI_SSTB_CTRL_LEN16, SSTB_CTRL);
	214	PUT(GET(SPTB_CTRL) \| SUNI_SPTB_CTRL_LEN16, SPTB_CTRL);
	215	}
	216
	217	REG_CHANGE(SUNI_TPOP_APM_S, SUNI_TPOP_APM_S_SHIFT,
	218	SUNI_TPOP_S_SDH, TPOP_APM);
	219
	220	return 0;
	221	}
	222
	223
	224	static int get_framing(struct atm_dev dev, void __user arg)
	225	{
	226	int framing;
	227	unsigned char s;
	228
	229
	230	s = (GET(TPOP_APM) & SUNI_TPOP_APM_S) >> SUNI_TPOP_APM_S_SHIFT;
	231	if (s == SUNI_TPOP_S_SONET)
	232	framing = SONET_FRAME_SONET;
	233	else
	234	framing = SONET_FRAME_SDH;
	235
	236	return put_user(framing, (int __user *) arg) ? -EFAULT : 0;
	237	}
	238
	239	static int set_framing(struct atm_dev dev, void __user arg)
	240	{
	241	int mode;
	242
	243	if (get_user(mode, (int __user *) arg))
	244	return -EFAULT;
	245
	246	if (mode == SONET_FRAME_SONET)
	247	return set_sonet(dev);
	248	else if (mode == SONET_FRAME_SDH)
249	return set_sdh(dev);
250
251	return -EINVAL;
252	}
253
1da177e4 LT	254
	255	static int suni_ioctl(struct atm_dev dev,unsigned int cmd,void __user arg)
	256	{
	257	switch (cmd) {
	258	case SONET_GETSTATZ:
	259	case SONET_GETSTAT:
	260	return fetch_stats(dev, arg, cmd == SONET_GETSTATZ);
	261	case SONET_SETDIAG:
	262	return change_diag(dev,arg,1);
	263	case SONET_CLRDIAG:
	264	return change_diag(dev,arg,0);
	265	case SONET_GETDIAG:
	266	return get_diag(dev,arg);
	267	case SONET_SETFRAMING:
df3bc8bd CW	268	if (!capable(CAP_NET_ADMIN))
	269	return -EPERM;
	270	return set_framing(dev, arg);
1da177e4	271	case SONET_GETFRAMING:
df3bc8bd	272	return get_framing(dev, arg);
1da177e4 LT	273	case SONET_GETFRSENSE:
	274	return -EINVAL;
	275	case ATM_SETLOOP:
df3bc8bd CW	276	if (!capable(CAP_NET_ADMIN))
df3bc8bd CW	277	return -EPERM;
1da177e4 LT	278	return set_loopback(dev,(int)(unsigned long)arg);
	279	case ATM_GETLOOP:
	280	return put_user(PRIV(dev)->loop_mode,(int __user *)arg) ?
	281	-EFAULT : 0;
	282	case ATM_QUERYLOOP:
	283	return put_user(ATM_LM_LOC_PHY \| ATM_LM_RMT_PHY,
	284	(int __user *) arg) ? -EFAULT : 0;
	285	default:
	286	return -ENOIOCTLCMD;
	287	}
	288	}
	289
	290
	291	static void poll_los(struct atm_dev *dev)
	292	{
e0b901a9 KH	293	atm_dev_signal_change(dev,
	294	GET(RSOP_SIS) & SUNI_RSOP_SIS_LOSV ?
	295	ATM_PHY_SIG_LOST : ATM_PHY_SIG_FOUND);
1da177e4 LT	296	}
	297
	298
	299	static void suni_int(struct atm_dev *dev)
	300	{
	301	poll_los(dev);
	302	printk(KERN_NOTICE "%s(itf %d): signal %s\n",dev->type,dev->number,
	303	dev->signal == ATM_PHY_SIG_LOST ? "lost" : "detected again");
	304	}
	305
	306
	307	static int suni_start(struct atm_dev *dev)
	308	{
	309	unsigned long flags;
	310	int first;
	311
1da177e4 LT	312	spin_lock_irqsave(&sunis_lock,flags);
	313	first = !sunis;
	314	PRIV(dev)->next = sunis;
	315	sunis = PRIV(dev);
	316	spin_unlock_irqrestore(&sunis_lock,flags);
	317	memset(&PRIV(dev)->sonet_stats,0,sizeof(struct k_sonet_stats));
	318	PUT(GET(RSOP_CIE) \| SUNI_RSOP_CIE_LOSE,RSOP_CIE);
	319	/* interrupt on loss of signal */
	320	poll_los(dev); /* ... and clear SUNI interrupts */
	321	if (dev->signal == ATM_PHY_SIG_LOST)
	322	printk(KERN_WARNING "%s(itf %d): no signal\n",dev->type,
	323	dev->number);
	324	PRIV(dev)->loop_mode = ATM_LM_NONE;
	325	suni_hz(0); /* clear SUNI counters */
	326	(void) fetch_stats(dev,NULL,1); /* clear kernel counters */
	327	if (first) {
	328	init_timer(&poll_timer);
	329	poll_timer.expires = jiffies+HZ;
	330	poll_timer.function = suni_hz;
	331	poll_timer.data = 1;
	332	#if 0
	333	printk(KERN_DEBUG "[u] p=0x%lx,n=0x%lx\n",(unsigned long) poll_timer.list.prev,
	334	(unsigned long) poll_timer.list.next);
	335	#endif
	336	add_timer(&poll_timer);
	337	}
	338	return 0;
	339	}
	340
	341
	342	static int suni_stop(struct atm_dev *dev)
	343	{
	344	struct suni_priv **walk;
	345	unsigned long flags;
	346
	347	/* let SAR driver worry about stopping interrupts */
	348	spin_lock_irqsave(&sunis_lock,flags);
	349	for (walk = &sunis; *walk != PRIV(dev);
	350	walk = &PRIV((*walk)->dev)->next);
	351	walk = PRIV((walk)->dev)->next;
	352	if (!sunis) del_timer_sync(&poll_timer);
	353	spin_unlock_irqrestore(&sunis_lock,flags);
	354	kfree(PRIV(dev));
	355
	356	return 0;
	357	}
	358
	359
	360	static const struct atmphy_ops suni_ops = {
	361	.start = suni_start,
	362	.ioctl = suni_ioctl,
	363	.interrupt = suni_int,
	364	.stop = suni_stop,
	365	};
	366
	367
421c9914	368	int suni_init(struct atm_dev *dev)
1da177e4 LT	369	{
	370	unsigned char mri;
	371
df3bc8bd CW	372	if (!(dev->phy_data = kmalloc(sizeof(struct suni_priv),GFP_KERNEL)))
	373	return -ENOMEM;
	374	PRIV(dev)->dev = dev;
	375
1da177e4	376	mri = GET(MRI); /* reset SUNI */
df3bc8bd	377	PRIV(dev)->type = (mri & SUNI_MRI_TYPE) >> SUNI_MRI_TYPE_SHIFT;
1da177e4 LT	378	PUT(mri \| SUNI_MRI_RESET,MRI);
	379	PUT(mri,MRI);
	380	PUT((GET(MT) & SUNI_MT_DS27_53),MT); /* disable all tests */
df3bc8bd	381	set_sonet(dev);
1da177e4 LT	382	REG_CHANGE(SUNI_TACP_IUCHP_CLP,0,SUNI_TACP_IUCHP_CLP,
	383	TACP_IUCHP); /* idle cells */
	384	PUT(SUNI_IDLE_PATTERN,TACP_IUCPOP);
	385	dev->phy = &suni_ops;
df3bc8bd	386
1da177e4 LT	387	return 0;
	388	}
	389
	390	EXPORT_SYMBOL(suni_init);
	391
	392	MODULE_LICENSE("GPL");