release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/atm/suni.c

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