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

   1 /* drivers/atm/uPD98402.c - NEC uPD98402 (PHY) declarations */
   2
   3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
   4
   5
   6 #include <linux/module.h>
   7 #include <linux/mm.h>
   8 #include <linux/errno.h>
   9 #include <linux/atmdev.h>
  10 #include <linux/sonet.h>
  11 #include <linux/init.h>
  12 #include <linux/slab.h>
  13 #include <asm/uaccess.h>
  14 #include <asm/atomic.h>
  15
  16 #include "uPD98402.h"
  17
  18
  19 #define DPRINTK(format,args...)
  20
  21
  22 struct uPD98402_priv {
  23         struct k_sonet_stats sonet_stats;/* link diagnostics */
  24         unsigned char framing;          /* SONET/SDH framing */
  25         int loop_mode;                  /* loopback mode */
  26         spinlock_t lock;
  27 };
  28
  29
  30 #define PRIV(dev) ((struct uPD98402_priv *) dev->phy_data)
  31
  32 #define PUT(val,reg) dev->ops->phy_put(dev,val,uPD98402_##reg)
  33 #define GET(reg) dev->ops->phy_get(dev,uPD98402_##reg)
  34
  35
  36 static int fetch_stats(struct atm_dev *dev,struct sonet_stats __user *arg,int zero)
  37 {
  38         struct sonet_stats tmp;
  39         int error = 0;
  40
  41         atomic_add(GET(HECCT),&PRIV(dev)->sonet_stats.uncorr_hcs);
  42         sonet_copy_stats(&PRIV(dev)->sonet_stats,&tmp);
  43         if (arg) error = copy_to_user(arg,&tmp,sizeof(tmp));
  44         if (zero && !error) {
  45                 /* unused fields are reported as -1, but we must not "adjust"
  46                    them */
  47                 tmp.corr_hcs = tmp.tx_cells = tmp.rx_cells = 0;
  48                 sonet_subtract_stats(&PRIV(dev)->sonet_stats,&tmp);
  49         }
  50         return error ? -EFAULT : 0;
  51 }
  52
  53
  54 static int set_framing(struct atm_dev *dev,unsigned char framing)
  55 {
  56         static const unsigned char sonet[] = { 1,2,3,0 };
  57         static const unsigned char sdh[] = { 1,0,0,2 };
  58         const char *set;
  59         unsigned long flags;
  60
  61         switch (framing) {
  62                 case SONET_FRAME_SONET:
  63                         set = sonet;
  64                         break;
  65                 case SONET_FRAME_SDH:
  66                         set = sdh;
  67                         break;
  68                 default:
  69                         return -EINVAL;
  70         }
  71         spin_lock_irqsave(&PRIV(dev)->lock, flags);
  72         PUT(set[0],C11T);
  73         PUT(set[1],C12T);
  74         PUT(set[2],C13T);
  75         PUT((GET(MDR) & ~uPD98402_MDR_SS_MASK) | (set[3] <<
  76             uPD98402_MDR_SS_SHIFT),MDR);
  77         spin_unlock_irqrestore(&PRIV(dev)->lock, flags);
  78         return 0;
  79 }
  80
  81
  82 static int get_sense(struct atm_dev *dev,u8 __user *arg)
  83 {
  84         unsigned long flags;
  85         unsigned char s[3];
  86
  87         spin_lock_irqsave(&PRIV(dev)->lock, flags);
  88         s[0] = GET(C11R);
  89         s[1] = GET(C12R);
  90         s[2] = GET(C13R);
  91         spin_unlock_irqrestore(&PRIV(dev)->lock, flags);
  92         return (put_user(s[0], arg) || put_user(s[1], arg+1) ||
  93             put_user(s[2], arg+2) || put_user(0xff, arg+3) ||
  94             put_user(0xff, arg+4) || put_user(0xff, arg+5)) ? -EFAULT : 0;
  95 }
  96
  97
  98 static int set_loopback(struct atm_dev *dev,int mode)
  99 {
 100         unsigned char mode_reg;
 101
 102         mode_reg = GET(MDR) & ~(uPD98402_MDR_TPLP | uPD98402_MDR_ALP |
 103             uPD98402_MDR_RPLP);
 104         switch (__ATM_LM_XTLOC(mode)) {
 105                 case __ATM_LM_NONE:
 106                         break;
 107                 case __ATM_LM_PHY:
 108                         mode_reg |= uPD98402_MDR_TPLP;
 109                         break;
 110                 case __ATM_LM_ATM:
 111                         mode_reg |= uPD98402_MDR_ALP;
 112                         break;
 113                 default:
 114                         return -EINVAL;
 115         }
 116         switch (__ATM_LM_XTRMT(mode)) {
 117                 case __ATM_LM_NONE:
 118                         break;
 119                 case __ATM_LM_PHY:
 120                         mode_reg |= uPD98402_MDR_RPLP;
 121                         break;
 122                 default:
 123                         return -EINVAL;
 124         }
 125         PUT(mode_reg,MDR);
 126         PRIV(dev)->loop_mode = mode;
 127         return 0;
 128 }
 129
 130
 131 static int uPD98402_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
 132 {
 133         switch (cmd) {
 134
 135                 case SONET_GETSTATZ:
 136                 case SONET_GETSTAT:
 137                         return fetch_stats(dev,arg, cmd == SONET_GETSTATZ);
 138                 case SONET_SETFRAMING:
 139                         return set_framing(dev, (int)(unsigned long)arg);
 140                 case SONET_GETFRAMING:
 141                         return put_user(PRIV(dev)->framing,(int __user *)arg) ?
 142                             -EFAULT : 0;
 143                 case SONET_GETFRSENSE:
 144                         return get_sense(dev,arg);
 145                 case ATM_SETLOOP:
 146                         return set_loopback(dev, (int)(unsigned long)arg);
 147                 case ATM_GETLOOP:
 148                         return put_user(PRIV(dev)->loop_mode,(int __user *)arg) ?
 149                             -EFAULT : 0;
 150                 case ATM_QUERYLOOP:
 151                         return put_user(ATM_LM_LOC_PHY | ATM_LM_LOC_ATM |
 152                             ATM_LM_RMT_PHY,(int __user *)arg) ? -EFAULT : 0;
 153                 default:
 154                         return -ENOIOCTLCMD;
 155         }
 156 }
 157
 158
 159 #define ADD_LIMITED(s,v) \
 160     { atomic_add(GET(v),&PRIV(dev)->sonet_stats.s); \
 161     if (atomic_read(&PRIV(dev)->sonet_stats.s) < 0) \
 162         atomic_set(&PRIV(dev)->sonet_stats.s,INT_MAX); }
 163
 164
 165 static void stat_event(struct atm_dev *dev)
 166 {
 167         unsigned char events;
 168
 169         events = GET(PCR);
 170         if (events & uPD98402_PFM_PFEB) ADD_LIMITED(path_febe,PFECB);
 171         if (events & uPD98402_PFM_LFEB) ADD_LIMITED(line_febe,LECCT);
 172         if (events & uPD98402_PFM_B3E) ADD_LIMITED(path_bip,B3ECT);
 173         if (events & uPD98402_PFM_B2E) ADD_LIMITED(line_bip,B2ECT);
 174         if (events & uPD98402_PFM_B1E) ADD_LIMITED(section_bip,B1ECT);
 175 }
 176
 177
 178 #undef ADD_LIMITED
 179
 180
 181 static void uPD98402_int(struct atm_dev *dev)
 182 {
 183         static unsigned long silence = 0;
 184         unsigned char reason;
 185
 186         while ((reason = GET(PICR))) {
 187                 if (reason & uPD98402_INT_LOS)
 188                         printk(KERN_NOTICE "%s(itf %d): signal lost\n",
 189                             dev->type,dev->number);
 190                 if (reason & uPD98402_INT_PFM) stat_event(dev);
 191                 if (reason & uPD98402_INT_PCO) {
 192                         (void) GET(PCOCR); /* clear interrupt cause */
 193                         atomic_add(GET(HECCT),
 194                             &PRIV(dev)->sonet_stats.uncorr_hcs);
 195                 }
 196                 if ((reason & uPD98402_INT_RFO) &&
 197                     (time_after(jiffies, silence) || silence == 0)) {
 198                         printk(KERN_WARNING "%s(itf %d): uPD98402 receive "
 199                             "FIFO overflow\n",dev->type,dev->number);
 200                         silence = (jiffies+HZ/2)|1;
 201                 }
 202         }
 203 }
 204
 205
 206 static int uPD98402_start(struct atm_dev *dev)
 207 {
 208         DPRINTK("phy_start\n");
 209         if (!(dev->dev_data = kmalloc(sizeof(struct uPD98402_priv),GFP_KERNEL)))
 210                 return -ENOMEM;
 211         spin_lock_init(&PRIV(dev)->lock);
 212         memset(&PRIV(dev)->sonet_stats,0,sizeof(struct k_sonet_stats));
 213         (void) GET(PCR); /* clear performance events */
 214         PUT(uPD98402_PFM_FJ,PCMR); /* ignore frequency adj */
 215         (void) GET(PCOCR); /* clear overflows */
 216         PUT(~uPD98402_PCO_HECC,PCOMR);
 217         (void) GET(PICR); /* clear interrupts */
 218         PUT(~(uPD98402_INT_PFM | uPD98402_INT_ALM | uPD98402_INT_RFO |
 219           uPD98402_INT_LOS),PIMR); /* enable them */
 220         (void) fetch_stats(dev,NULL,1); /* clear kernel counters */
 221         atomic_set(&PRIV(dev)->sonet_stats.corr_hcs,-1);
 222         atomic_set(&PRIV(dev)->sonet_stats.tx_cells,-1);
 223         atomic_set(&PRIV(dev)->sonet_stats.rx_cells,-1);
 224         return 0;
 225 }
 226
 227
 228 static int uPD98402_stop(struct atm_dev *dev)
 229 {
 230         /* let SAR driver worry about stopping interrupts */
 231         kfree(PRIV(dev));
 232         return 0;
 233 }
 234
 235
 236 static const struct atmphy_ops uPD98402_ops = {
 237         .start          = uPD98402_start,
 238         .ioctl          = uPD98402_ioctl,
 239         .interrupt      = uPD98402_int,
 240         .stop           = uPD98402_stop,
 241 };
 242
 243
 244 int uPD98402_init(struct atm_dev *dev)
 245 {
 246 DPRINTK("phy_init\n");
 247         dev->phy = &uPD98402_ops;
 248         return 0;
 249 }
 250
 251
 252 MODULE_LICENSE("GPL");
 253
 254 EXPORT_SYMBOL(uPD98402_init);
 255
 256 static __init int uPD98402_module_init(void)
 257 {
 258         return 0;
 259 }
 260 module_init(uPD98402_module_init);
 261 /* module_exit not defined so not unloadable */