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