uPD98402.c 6.5 KB

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