package/kernel/ar7-atm/patches-D7.04.03.00/220-3.10-update_proc_code.patch

   1 From 2826b9f6aa1ad2ac4c2846bbce10eb3378014555 Mon Sep 17 00:00:00 2001
   2 From: Jonas Gorski <jogo@openwrt.org>
   3 Date: Thu, 26 Sep 2013 12:28:35 +0200
   4 Subject: [PATCH 3/3] update proc code to fix compilation for 3.10
   5
   6 Signed-off-by: Jonas Gorski <jogo@openwrt.org>
   7 ---
   8  tn7api.h |   63 ++-
   9  tn7atm.c |  330 ++++++--------
  10  tn7dsl.c | 1447 ++++++++++++++++++++++++++++++--------------------------------
  11  tn7sar.c |   91 ++--
  12  4 files changed, 922 insertions(+), 1009 deletions(-)
  13
  14 --- a/tn7api.h
  15 +++ b/tn7api.h
  16 @@ -86,27 +86,26 @@ void * tn7atm_memcpy(void * dst, void co
  17  /* tn7dsl.h */
  18  void tn7dsl_exit(void);
  19  int tn7dsl_init(void *priv);
  20 -int tn7dsl_proc_eoc(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  21 -int tn7dsl_proc_stats(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  22 +extern struct file_operations tn7dsl_proc_eoc_fops;
  23 +extern struct file_operations tn7dsl_proc_stats_fops;
  24
  25  //#define ADV_DIAG_STATS  1  //CQ10275 To enable Adv Stats
  26
  27  #ifdef ADV_DIAG_STATS
  28 -int tn7dsl_proc_adv_stats(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  29 -int tn7dsl_proc_adv_stats1(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  30 -int tn7dsl_proc_adv_stats2(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  31 -int tn7dsl_proc_adv_stats3(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  32 +extern struct file_operations tn7dsl_proc_adv_stats_fops;
  33 +extern struct file_operations tn7dsl_proc_adv1_stats_fops;
  34 +extern struct file_operations tn7dsl_proc_adv2_stats_fops;
  35 +extern struct file_operations tn7dsl_proc_adv3_stats_fops;
  36  //UR8_MERGE_START CQ10682   Jack Zhang
  37 -int tn7dsl_proc_dbg_cmsgs(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  38 -int tn7dsl_proc_dbg_rmsgs1(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  39 -int tn7dsl_proc_dbg_rmsgs2(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  40 -int tn7dsl_proc_dbg_rmsgs3(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  41 -int tn7dsl_proc_dbg_rmsgs4(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  42 +extern struct file_operations tn7dsl_proc_dbg_cmsgs_fops;
  43 +extern struct file_operations tn7dsl_proc_dbg_cmsgs1_fops;
  44 +extern struct file_operations tn7dsl_proc_dbg_cmsgs2_fops;
  45 +extern struct file_operations tn7dsl_proc_dbg_cmsgs3_fops;
  46 +extern struct file_operations tn7dsl_proc_dbg_cmsgs4_fops;
  47  //UR8_MERGE_END   CQ10682*
  48  #endif //ADV_DIAG_STATS
  49
  50 -int tn7dsl_proc_write_stats(struct file *fp, const char * buf, unsigned long count, void * data);
  51 -int tn7dsl_proc_modem(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  52 +extern struct file_operations tn7dsl_proc_modem_fops;
  53  int tn7dsl_handle_interrupt(void);
  54
  55  void tn7dsl_dslmod_sysctl_register(void);
  56 @@ -127,31 +126,31 @@ unsigned int tn7dsl_get_memory(unsigned
  57  int os_atoi(const char *pStr);
  58  int os_atoh(const char *pStr);
  59  unsigned long os_atoul(const char *pStr);
  60 -int tn7dsl_proc_snr0(char* buf, char **start, off_t offset, int count, int *eof, void *data);
  61 -int tn7dsl_proc_snr1(char* buf, char **start, off_t offset, int count, int *eof, void *data);
  62 -int tn7dsl_proc_snr2(char* buf, char **start, off_t offset, int count, int *eof, void *data);
  63 -int tn7dsl_proc_bit_allocation(char* buf, char **start, off_t offset, int count, int *eof, void *data);
  64 -int tn7dsl_proc_ds_noise(char* buf, char **start, off_t offset, int count, int *eof, void *data);
  65 -int tn7dsl_proc_generic_read_result(char* buf, char **start, off_t offset, int count, int *eof, void *data);
  66 -int tn7dsl_proc_train_mode_export(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  67 +extern struct file_operations tn7dsl_proc_snr0_fops;
  68 +extern struct file_operations tn7dsl_proc_snr1_fops;
  69 +extern struct file_operations tn7dsl_proc_snr2_fops;
  70 +extern struct file_operations tn7dsl_proc_bit_allocation_fops;
  71 +extern struct file_operations tn7dsl_proc_ds_noise_fops;
  72 +extern struct file_operations tn7dsl_proc_generic_read_result_fops;
  73 +extern struct file_operations tn7dsl_proc_train_mode_export_fops;
  74
  75  #ifndef NO_ADV_STATS
  76 -int tn7dsl_proc_SNRpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  77 -int tn7dsl_proc_QLNpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  78 +extern struct file_operations tn7dsl_proc_SNRpsds_fops;
  79 +extern struct file_operations tn7dsl_proc_QLNpsds_fops;
  80  // *    UR8_MERGE_START CQ10979   Jack Zhang
  81  #ifdef TR69_HLIN_IN
  82 -//int tn7dsl_proc_HLINpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  83 -int tn7dsl_proc_HLINpsds1(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  84 -int tn7dsl_proc_HLINpsds2(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  85 -int tn7dsl_proc_HLINpsds3(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  86 -int tn7dsl_proc_HLINpsds4(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  87 +//extern struct file_operations tn7dsl_proc_HLINpsds_fops;
  88 +extern struct file_operations tn7dsl_proc_HLINpsds1_fops;
  89 +extern struct file_operations tn7dsl_proc_HLINpsds2_fops;
  90 +extern struct file_operations tn7dsl_proc_HLINpsds3_fops;
  91 +extern struct file_operations tn7dsl_proc_HLINpsds4_fops;
  92  #endif //TR69_HLIN_IN
  93  // *    UR8_MERGE_END   CQ10979*
  94  // *    UR8_MERGE_START CQ11057   Jack Zhang
  95  #define TR69_PMD_IN
  96  #ifdef TR69_PMD_IN
  97 -//int tn7dsl_proc_PMDus(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  98 -int tn7dsl_proc_PMDus(char* buf, char **start, off_t offset, int count,int *eof, void *data);
  99 +//extern struct file_operations tn7dsl_proc_PMDus_fops;
 100 +extern struct file_operations tn7dsl_proc_PMDus_fops;
 101  #endif  //TR69_PMD_IN
 102  // *    UR8_MERGE_END   CQ11057 *
 103  #endif
 104 @@ -168,9 +167,9 @@ void tn7sar_get_sar_version(Tn7AtmPrivat
 105  int tn7sar_get_near_end_loopback_count(unsigned int *pF4count, unsigned int *pF5count);
 106  int tn7sar_oam_generation(void *privContext, int chan, int type, int vpi, int vci, int timeout);
 107  int tn7sar_get_stats(void *priv1);
 108 -int tn7sar_proc_sar_stat(char* buf, char **start, off_t offset, int count,int *eof, void *data);
 109 +extern struct file_operations tn7sar_proc_sar_stat_fops;
 110  void tn7sar_get_sar_firmware_version(unsigned int *pdsp_version_ms, unsigned int *pdsp_version_ls);
 111 -int tn7sar_proc_oam_ping(char* buf, char **start, off_t offset, int count,int *eof, void *data);
 112 -int tn7sar_proc_pvc_table(char* buf, char **start, off_t offset, int count,int *eof, void *data);
 113 +extern struct file_operations tn7sar_proc_oam_ping_fops;
 114 +extern struct file_operations tn7sar_proc_pvc_table_fops;
 115  int tn7sar_tx_flush(void *privContext, int chan, int queue, int skip);
 116  #endif __SGAPI_H
 117 --- a/tn7atm.c
 118 +++ b/tn7atm.c
 119 @@ -277,25 +277,15 @@ static int tn7atm_change_qos (struct atm
 120  static int tn7atm_detect (void);
 121  static int tn7atm_init (struct atm_dev *dev);
 122  static int tn7atm_irq_request (struct atm_dev *dev);
 123 -static int tn7atm_proc_version (char *buf, char **start, off_t offset,
 124 -                                int count, int *eof, void *data);
 125 +
 126 +static struct file_operations tn7atm_proc_version_fops;
 127  static void tn7atm_exit (void);
 128 -static int tn7atm_proc_channels (char *buf, char **start, off_t offset,
 129 -                                 int count, int *eof, void *data);
 130 -static int tn7atm_proc_private (char *buf, char **start, off_t offset,
 131 -                                int count, int *eof, void *data);
 132 +static struct file_operations tn7atm_proc_channels_fops;
 133 +static struct file_operations tn7atm_proc_private_fops;
 134  inline static int tn7atm_queue_packet_to_sar (void *vcc1, void *skb1,
 135                                                int chan);
 136
 137 -static int tn7atm_xlate_proc_name (const char *name,
 138 -                                   struct proc_dir_entry **ret,
 139 -                                   const char **residual);
 140 -static int tn7atm_proc_match (int len, const char *name,
 141 -                              struct proc_dir_entry *de);
 142 -static int tn7atm_proc_qos_read  (char *buf, char **start, off_t offset,
 143 -                                  int count, int *eof, void *data);
 144 -static int tn7atm_proc_qos_write (struct file *fp, const char *buf,
 145 -                                  unsigned long count, void *data);
 146 +static struct file_operations tn7atm_proc_qos_fops;
 147
 148  //CT - Added function to return chipset Id
 149         void tn7atm_get_chipsetId (char *pVerId);
 150 @@ -415,63 +405,67 @@ const char drv_proc_root_folder[] = "ava
 151  static struct proc_dir_entry *root_proc_dir_entry = NULL;
 152  #define DRV_PROC_MODE 0644
 153  static int proc_root_already_exists = TRUE;
 154 +
 155 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 156 +#define PDE_DATA(inode) PDE(inode)->data
 157 +#endif
 158 +
 159  static struct
 160  {
 161      const unsigned char name[32];
 162 -    int (*read_func) (char* , char **, off_t , int ,int *, void *);
 163 -    int (*write_func) (struct file *, const char * , unsigned long , void *);
 164 +    struct file_operations *fops;
 165
 166  } proc_if[] = {
 167 -    {"avsar_ver",                   tn7atm_proc_version,           NULL},
 168 -    {"avsar_channels",              tn7atm_proc_channels,          NULL},
 169 -    {"avsar_sarhal_stats",          tn7sar_proc_sar_stat,          NULL},
 170 -    {"avsar_oam_ping",              tn7sar_proc_oam_ping,          NULL},
 171 -    {"avsar_pvc_table",             tn7sar_proc_pvc_table,         NULL},
 172 -    {"avsar_rxsnr0",                tn7dsl_proc_snr0,              NULL},
 173 -    {"avsar_rxsnr1",                tn7dsl_proc_snr1,              NULL},
 174 -    {"avsar_rxsnr2",                tn7dsl_proc_snr2,              NULL},
 175 -    {"clear_eoc_stats",             tn7dsl_proc_eoc,               NULL},
 176 -    {"avsar_bit_allocation_table",  tn7dsl_proc_bit_allocation,    NULL},
 177 -    {"avsar_dsl_modulation_schemes",tn7dsl_proc_train_mode_export, NULL},
 178 +    {"avsar_ver",                   &tn7atm_proc_version_fops},
 179 +    {"avsar_channels",              &tn7atm_proc_channels_fops},
 180 +    {"avsar_sarhal_stats",          &tn7sar_proc_sar_stat_fops},
 181 +    {"avsar_oam_ping",              &tn7sar_proc_oam_ping_fops},
 182 +    {"avsar_pvc_table",             &tn7sar_proc_pvc_table_fops},
 183 +    {"avsar_rxsnr0",                &tn7dsl_proc_snr0_fops},
 184 +    {"avsar_rxsnr1",                &tn7dsl_proc_snr1_fops},
 185 +    {"avsar_rxsnr2",                &tn7dsl_proc_snr2_fops},
 186 +    {"clear_eoc_stats",             &tn7dsl_proc_eoc_fops},
 187 +    {"avsar_bit_allocation_table",  &tn7dsl_proc_bit_allocation_fops},
 188 +    {"avsar_dsl_modulation_schemes",&tn7dsl_proc_train_mode_export_fops},
 189  #ifndef NO_ADV_STATS
 190 -    {"avsar_SNRpsds",               tn7dsl_proc_SNRpsds,           NULL},
 191 -    {"avsar_QLNpsds",               tn7dsl_proc_QLNpsds,           NULL},
 192 +    {"avsar_SNRpsds",               &tn7dsl_proc_SNRpsds_fops},
 193 +    {"avsar_QLNpsds",               &tn7dsl_proc_QLNpsds_fops},
 194  // *    UR8_MERGE_START CQ10979   Jack Zhang
 195  #ifdef TR69_HLIN_IN
 196 -//    {"avsar_HLINpsds",              tn7dsl_proc_HLINpsds,          NULL},
 197 -    {"avsar_HLINpsds1",             tn7dsl_proc_HLINpsds1,         NULL},
 198 -    {"avsar_HLINpsds2",             tn7dsl_proc_HLINpsds2,         NULL},
 199 -    {"avsar_HLINpsds3",             tn7dsl_proc_HLINpsds3,         NULL},
 200 -    {"avsar_HLINpsds4",             tn7dsl_proc_HLINpsds4,         NULL},
 201 +//    {"avsar_HLINpsds",              &tn7dsl_proc_HLINpsds_fops},
 202 +    {"avsar_HLINpsds1",             &tn7dsl_proc_HLINpsds1_fops},
 203 +    {"avsar_HLINpsds2",             &tn7dsl_proc_HLINpsds2_fops},
 204 +    {"avsar_HLINpsds3",             &tn7dsl_proc_HLINpsds3_fops},
 205 +    {"avsar_HLINpsds4",             &tn7dsl_proc_HLINpsds4_fops},
 206  #endif //TR69_HLIN_IN
 207  // *    UR8_MERGE_END   CQ10979*
 208  // *    UR8_MERGE_START CQ11057   Jack Zhang
 209  #define TR69_PMD_IN
 210  #ifdef TR69_PMD_IN
 211 -    {"avsar_PMDTestus",             tn7dsl_proc_PMDus,            NULL},
 212 -//    {"avsar_PMDTestus1",          tn7dsl_proc_PMDus1,            NULL},
 213 +    {"avsar_PMDTestus",             &tn7dsl_proc_PMDus_fops},
 214 +//    {"avsar_PMDTestus1",          &tn7dsl_proc_PMDus1_fops},
 215  #endif  //TR69_PMD_IN
 216  // *    UR8_MERGE_END   CQ11057 *
 217  #endif
 218 -    {"avsar_private",               tn7atm_proc_private,           NULL},
 219 -    {"avsar_modem_training",        tn7dsl_proc_modem,             NULL},
 220 -    {"avsar_modem_stats",           tn7dsl_proc_stats,             tn7dsl_proc_write_stats},
 221 +    {"avsar_private",               &tn7atm_proc_private_fops},
 222 +    {"avsar_modem_training",        &tn7dsl_proc_modem_fops},
 223 +    {"avsar_modem_stats",           &tn7dsl_proc_stats_fops},
 224
 225  #ifdef ADV_DIAG_STATS //CQ10275
 226 -//for 2.6    {"avsar_modem_adv_stats",       tn7dsl_proc_adv_stats,         NULL},
 227 +//for 2.6    {"avsar_modem_adv_stats",       &tn7dsl_proc_adv_stats_fops},
 228  //For 2.4 kernel, due to proc file system size limitation
 229 -    {"avsar_modem_adv_stats1",      tn7dsl_proc_adv_stats1,        NULL},
 230 -    {"avsar_modem_adv_stats2",      tn7dsl_proc_adv_stats2,        NULL},
 231 -    {"avsar_modem_adv_stats3",      tn7dsl_proc_adv_stats3,        NULL},
 232 +    {"avsar_modem_adv_stats1",      &tn7dsl_proc_adv_stats1_fops},
 233 +    {"avsar_modem_adv_stats2",      &tn7dsl_proc_adv_stats2_fops},
 234 +    {"avsar_modem_adv_stats3",      &tn7dsl_proc_adv_stats3_fops},
 235  //UR8_MERGE_START CQ10682   Jack Zhang
 236 -    {"avsar_modem_dbg_cmsgs",       tn7dsl_proc_dbg_cmsgs,         NULL},
 237 -    {"avsar_modem_dbg_rmsgs1",      tn7dsl_proc_dbg_rmsgs1,        NULL},
 238 -    {"avsar_modem_dbg_rmsgs2",      tn7dsl_proc_dbg_rmsgs2,        NULL},
 239 -    {"avsar_modem_dbg_rmsgs3",      tn7dsl_proc_dbg_rmsgs3,        NULL},
 240 -    {"avsar_modem_dbg_rmsgs4",      tn7dsl_proc_dbg_rmsgs4,        NULL},
 241 +    {"avsar_modem_dbg_cmsgs",       &tn7dsl_proc_dbg_cmsgs_fops},
 242 +    {"avsar_modem_dbg_rmsgs1",      &tn7dsl_proc_dbg_rmsgs1_fops},
 243 +    {"avsar_modem_dbg_rmsgs2",      &tn7dsl_proc_dbg_rmsgs2_fops},
 244 +    {"avsar_modem_dbg_rmsgs3",      &tn7dsl_proc_dbg_rmsgs3_fops},
 245 +    {"avsar_modem_dbg_rmsgs4",      &tn7dsl_proc_dbg_rmsgs4_fops},
 246  // UR8_MERGE_END   CQ10682*
 247  #endif //ADV_DIAG_STATS
 248 -    {"avsar_qos_enable",            tn7atm_proc_qos_read,          tn7atm_proc_qos_write}
 249 +    {"avsar_qos_enable",            &tn7atm_proc_qos_fops}
 250  };
 251
 252  /* *INDENT-ON* */
 253 @@ -1709,75 +1703,81 @@ int tn7atm_receive (void *os_dev, int ch
 254    return 0;
 255  }
 256
 257 -static int tn7atm_proc_channels (char *buf, char **start, off_t offset,
 258 -                                 int count, int *eof, void *data)
 259 +static int tn7atm_proc_channels (struct seq_file *m, void *data)
 260  {
 261 -  int len = 0;
 262 -  int limit = count - 80;
 263    int i;
 264
 265    struct atm_dev *dev;
 266    Tn7AtmPrivate *priv;
 267
 268 -  dev = (struct atm_dev *) data;
 269 +  dev = (struct atm_dev *) m->private;
 270    priv = (Tn7AtmPrivate *) dev->dev_data;
 271
 272 -  if (len <= limit)
 273 -    len += sprintf (buf + len, "Chan  Inuse   ChanID   VPI     VCI \n");
 274 -  if (len <= limit)
 275 -    len +=
 276 -      sprintf (buf + len,
 277 +  seq_printf (m, "Chan  Inuse   ChanID   VPI     VCI \n");
 278 +  seq_printf (m,
 279                 "------------------------------------------------------------------\n");
 280
 281    for (i = 0; i <= MAX_DMA_CHAN; i++)
 282    {
 283 -    if (len <= limit)
 284 -    {
 285 -      len += sprintf (buf + len,
 286 -                      " %02d    %05d   %05d   %05d   %05d \n",
 287 -                      i, priv->lut[i].inuse, priv->lut[i].chanid,
 288 -                      priv->lut[i].vpi, priv->lut[i].vci);
 289 -    }
 290 +      seq_printf (m,
 291 +                  " %02d    %05d   %05d   %05d   %05d \n",
 292 +                  i, priv->lut[i].inuse, priv->lut[i].chanid,
 293 +                  priv->lut[i].vpi, priv->lut[i].vci);
 294    }
 295
 296 -  if (len <= limit)
 297 -    len +=
 298 -      sprintf (buf + len,
 299 +  seq_printf (m,
 300                 "------------------------------------------------------------------\n");
 301
 302 -  return len;
 303 +  return 0;
 304 +}
 305 +
 306 +static int tn7atm_proc_channels_open(struct inode *inode, struct file *file)
 307 +{
 308 +       return single_open(file, tn7atm_proc_channels, PDE_DATA(inode));
 309  }
 310
 311 -static int tn7atm_proc_private (char *buf, char **start, off_t offset,
 312 -                                int count, int *eof, void *data)
 313 +static struct file_operations tn7atm_proc_channels_fops = {
 314 +       .owner          = THIS_MODULE,
 315 +       .open           = tn7atm_proc_channels_open,
 316 +       .read           = seq_read,
 317 +       .llseek         = seq_lseek,
 318 +       .release        = single_release,
 319 +};
 320 +
 321 +
 322 +static int tn7atm_proc_private (struct seq_file *m, void *data)
 323  {
 324 -  int len = 0;
 325 -  int limit = count - 80;
 326    struct atm_dev *dev;
 327    Tn7AtmPrivate *priv;
 328
 329 -  dev = (struct atm_dev *) data;
 330 +  dev = (struct atm_dev *) m->private;
 331    priv = (Tn7AtmPrivate *) dev->dev_data;
 332
 333 -  if (len <= limit)
 334 -    len += sprintf (buf + len, "\nPrivate Data Structure(%s):\n", priv->name);
 335 -  if (len <= limit)
 336 -    len += sprintf (buf + len, "----------------------------------------\n");
 337 -  if (len <= limit)
 338 -    len += sprintf (buf + len, "priv:  0x%p\n", priv);
 339 -  if (len <= limit)
 340 -    len += sprintf (buf + len, "next:  0x%p", priv->next);
 341 -  if (len <= limit)
 342 -    len += sprintf (buf + len, "\tdev:   0x%p\n", priv->dev);
 343 -
 344 -  if (len <= limit)
 345 -    len += sprintf (buf + len, "tx_irq: %02d", priv->sar_irq);
 346 -  if (len <= limit)
 347 -    len += sprintf (buf + len, "rx_irq: %02d", priv->dsl_irq);
 348 +  seq_printf (m, "\nPrivate Data Structure(%s):\n", priv->name);
 349 +  seq_printf (m, "----------------------------------------\n");
 350 +  seq_printf (m, "priv:  0x%p\n", priv);
 351 +  seq_printf (m, "next:  0x%p", priv->next);
 352 +  seq_printf (m, "\tdev:   0x%p\n", priv->dev);
 353 +
 354 +  seq_printf (m, "tx_irq: %02d", priv->sar_irq);
 355 +  seq_printf (m, "rx_irq: %02d", priv->dsl_irq);
 356
 357 -  return len;
 358 +  return 0;
 359 +}
 360 +
 361 +static int tn7atm_proc_private_open(struct inode *inode, struct file *file)
 362 +{
 363 +       return single_open(file, tn7atm_proc_private, PDE_DATA(inode));
 364  }
 365
 366 +static struct file_operations tn7atm_proc_private_fops = {
 367 +       .owner          = THIS_MODULE,
 368 +       .open           = tn7atm_proc_private_open,
 369 +       .read           = seq_read,
 370 +       .llseek         = seq_lseek,
 371 +       .release        = single_release,
 372 +};
 373 +
 374  void tn7atm_sarhal_isr_register (void *os_dev, void *hal_isr,
 375                                   int interrupt_num)
 376  {
 377 @@ -1900,10 +1900,8 @@ static int __init tn7atm_register (Tn7At
 378    return ATM_REG_OK;
 379  }
 380
 381 -static int tn7atm_proc_version (char *buf, char **start, off_t offset,
 382 -                                int count, int *eof, void *data)
 383 +static int tn7atm_proc_version (struct seq_file *m, void *data)
 384  {
 385 -  int len = 0;
 386    char dslVer[8];
 387    char dspVer[10];
 388    char chipsetID[32]; //CT CQ10076 - Added temporary buffer to store chipset Id
 389 @@ -1914,56 +1912,64 @@ static int tn7atm_proc_version (char *bu
 390
 391    priv = mydev->dev_data;
 392
 393 -  len +=
 394 -    sprintf (buf + len, "ATM Driver version:[%d.%02d.%02d.%02d]\n",
 395 -             LINUXATM_VERSION_MAJOR, LINUXATM_VERSION_MINOR,
 396 -             LINUXATM_VERSION_BUGFIX, LINUXATM_VERSION_BUILDNUM);
 397 +  seq_printf (m, "ATM Driver version:[%d.%02d.%02d.%02d]\n",
 398 +              LINUXATM_VERSION_MAJOR, LINUXATM_VERSION_MINOR,
 399 +              LINUXATM_VERSION_BUGFIX, LINUXATM_VERSION_BUILDNUM);
 400
 401    tn7dsl_get_dslhal_version (dslVer);
 402
 403 -  len +=
 404 -    sprintf (buf + len, "DSL HAL version: [%d.%02d.%02d.%02d]\n", dslVer[0],
 405 -             dslVer[1], dslVer[2], dslVer[3]);
 406 +  seq_printf (m, "DSL HAL version: [%d.%02d.%02d.%02d]\n", dslVer[0],
 407 +              dslVer[1], dslVer[2], dslVer[3]);
 408    tn7dsl_get_dsp_version (dspVer);
 409
 410 -  len +=
 411 -    sprintf (buf + len, "DSP Datapump version: [%d.%02d.%02d.%02d] ",
 412 -             dspVer[4], dspVer[5], dspVer[6], dspVer[7]);
 413 +  seq_printf (m, "DSP Datapump version: [%d.%02d.%02d.%02d] ",
 414 +              dspVer[4], dspVer[5], dspVer[6], dspVer[7]);
 415    if (dspVer[8] == 2)           // annex B
 416 -    len += sprintf (buf + len, "Annex B\n");
 417 +    seq_printf (m, "Annex B\n");
 418    else if (dspVer[8] == 3)      // annex c
 419 -    len += sprintf (buf + len, "Annex c\n");
 420 +    seq_printf (m, "Annex c\n");
 421    else
 422 -    len += sprintf (buf + len, "Annex A\n");
 423 +    seq_printf (m, "Annex A\n");
 424
 425    tn7sar_get_sar_version (priv, &pSarVer);
 426
 427 -  len += sprintf (buf + len, "SAR HAL version: [");
 428 +  seq_printf (m, "SAR HAL version: [");
 429    for (i = 0; i < 8; i++)
 430    {
 431 -    len += sprintf (buf + len, "%c", pSarVer[i + 7]);
 432 +    seq_printf (m, "%c", pSarVer[i + 7]);
 433    }
 434 -  len += sprintf (buf + len, "]\n");
 435 +  seq_printf (m, "]\n");
 436
 437    tn7sar_get_sar_firmware_version (&pdspV1, &pdspV2);
 438 -  len += sprintf (buf + len, "PDSP Firmware version:[%01x.%02x]\n",
 439 +  seq_printf (m, "PDSP Firmware version:[%01x.%02x]\n",
 440                    pdspV1, pdspV2);
 441
 442    //CT CQ10076 - Added code to report chipset ID using proc file system
 443    tn7atm_get_chipsetId(chipsetID);
 444 -  len += sprintf (buf + len, "Chipset ID: [%s]\n",chipsetID);
 445 +  seq_printf (m, "Chipset ID: [%s]\n",chipsetID);
 446
 447 -  return len;
 448 +  return 0;
 449  }
 450
 451 +static int tn7atm_proc_version_open(struct inode *inode, struct file *file)
 452 +{
 453 +       return single_open(file, tn7atm_proc_version, PDE_DATA(inode));
 454 +}
 455 +
 456 +static struct file_operations tn7atm_proc_version_fops = {
 457 +       .owner          = THIS_MODULE,
 458 +       .open           = tn7atm_proc_version_open,
 459 +       .read           = seq_read,
 460 +       .llseek         = seq_lseek,
 461 +       .release        = single_release,
 462 +};
 463 +
 464
 465  /* Device detection */
 466
 467  static int __init tn7atm_detect (void)
 468  {
 469    Tn7AtmPrivate *priv;
 470 -  struct proc_dir_entry *dsl_wr_file = NULL; /* Only for ones with a write
 471 -                                                 * function. */
 472    int ctr;
 473    const char *residual;
 474
 475 @@ -2012,24 +2018,7 @@ static int __init tn7atm_detect (void)
 476     */
 477    for (ctr = 0; ctr < (NUM_ELEMS (proc_if)); ctr++)
 478    {
 479 -      /* Only if we have a write function, we create a normal proc file. */
 480 -      if(proc_if[ctr].write_func)
 481 -      {
 482 -          dsl_wr_file = create_proc_entry (proc_if[ctr].name, DRV_PROC_MODE, root_proc_dir_entry);
 483 -          if (dsl_wr_file)
 484 -          {
 485 -            dsl_wr_file->read_proc  = proc_if[ctr].read_func;
 486 -            dsl_wr_file->write_proc = proc_if[ctr].write_func;
 487 -            dsl_wr_file->data = (void *)mydev; //UR8_MERGE_START_END CQ10700 Manjula K
 488 -          }
 489 -          dsl_wr_file = NULL;
 490 -      }
 491 -      else
 492 -      {
 493 -          /* Create a read-only entry. */
 494 -          create_proc_read_entry (proc_if[ctr].name, 0, root_proc_dir_entry,
 495 -                             proc_if[ctr].read_func, mydev);
 496 -      }
 497 +    proc_create_data(proc_if[ctr].name, DRV_PROC_MODE, root_proc_dir_entry, proc_if[ctr].fops, (void *)mydev);
 498    }
 499
 500    tn7dsl_dslmod_sysctl_register ();
 501 @@ -2501,63 +2490,10 @@ static int tn7atm_set_can_support_adsl2
 502    return TRUE;
 503  }
 504
 505 -/*
 506 - * This function matches a name such as "serial", and that specified by the
 507 - * proc_dir_entry
 508 - */
 509 -static int tn7atm_proc_match (int len, const char *name,
 510 -                              struct proc_dir_entry *de)
 511 +static int tn7atm_proc_qos_read(struct seq_file *m, void *data)
 512  {
 513 -  if (!de || !de->low_ino)
 514 -    return 0;
 515 -  if (de->namelen != len)
 516 +    seq_printf (m, "\nEnableQoS = %d\n", EnableQoS);
 517      return 0;
 518 -  return !strncmp (name, de->name, len);
 519 -}
 520 -
 521 -/*
 522 - * This function parses a name such as "tty/driver/serial", and
 523 - * returns the struct proc_dir_entry for "/proc/tty/driver", and
 524 - * returns "serial" in residual.
 525 - */
 526 -static int tn7atm_xlate_proc_name (const char *name,
 527 -                                   struct proc_dir_entry **ret,
 528 -                                   const char **residual)
 529 -{
 530 -  const char *cp = name, *next;
 531 -  struct proc_dir_entry *de;
 532 -  int len;
 533 -  extern struct proc_dir_entry proc_root;
 534 -
 535 -  de = &proc_root;
 536 -  while (1)
 537 -  {
 538 -    next = strchr (cp, '/');
 539 -    if (!next)
 540 -      break;
 541 -
 542 -    len = next - cp;
 543 -    for (de = de->subdir; de; de = de->next)
 544 -    {
 545 -      if (tn7atm_proc_match (len, cp, de))
 546 -        break;
 547 -    }
 548 -    if (!de)
 549 -      return -ENOENT;
 550 -    cp += len + 1;
 551 -  }
 552 -  *residual = cp;
 553 -  *ret = de;
 554 -
 555 -  return 0;
 556 -}
 557 -
 558 -static int tn7atm_proc_qos_read(char *buf, char **start, off_t offset, int count, int *eof, void *data)
 559 -{
 560 -    int len = 0;
 561 -
 562 -    len += sprintf (buf + len, "\nEnableQoS = %d\n", EnableQoS);
 563 -    return len;
 564
 565  }
 566  static int tn7atm_proc_qos_write(struct file *fp, const char *buf, unsigned long count, void *data)
 567 @@ -2591,5 +2527,19 @@ static int tn7atm_proc_qos_write(struct
 568      return count;
 569  }
 570
 571 +static int tn7atm_proc_qos_open(struct inode *inode, struct file *file)
 572 +{
 573 +       return single_open(file, tn7atm_proc_qos_read, PDE_DATA(inode));
 574 +}
 575 +
 576 +static struct file_operations tn7atm_proc_qos_fops = {
 577 +       .owner          = THIS_MODULE,
 578 +       .open           = tn7atm_proc_qos_open,
 579 +       .read           = seq_read,
 580 +       .llseek         = seq_lseek,
 581 +       .release        = single_release,
 582 +       .write          = tn7atm_proc_qos_write,
 583 +};
 584 +
 585  module_init (tn7atm_detect);
 586  module_exit (tn7atm_exit);
 587 --- a/tn7dsl.c
 588 +++ b/tn7dsl.c
 589 @@ -221,6 +221,9 @@ static struct led_funcs ledreg[2];
 590
 591  #define tn7dsl_kfree_skb(x)      dev_kfree_skb(x)
 592
 593 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 594 +#define PDE_DATA(inode) PDE(inode)->data
 595 +#endif
 596
 597  //---------------------------------------------
 598  // Begin Clear EOC definitions
 599 @@ -349,7 +352,7 @@ static void tn7dsl_register_dslss_led(vo
 600  void tn7dsl_dslmod_sysctl_register(void);
 601  void tn7dsl_dslmod_sysctl_unregister(void);
 602  static int tn7dsl_clear_eoc_receive(void);
 603 -static int tn7dsl_proc_snr_print (char *buf, int count, int *eof, int data);
 604 +static int tn7dsl_proc_snr_print (struct seq_file *m, int data);
 605  /* end of internal functions */
 606
 607  //  UR8_MERGE_START CQ11054   Jack Zhang
 608 @@ -649,11 +652,9 @@ void shim_osCriticalExit(void)
 609    spin_unlock_irqrestore(&shimLock, flags);
 610  }
 611
 612 -static int tn7dsl_proc_snr_print (char *buf, int count, int *eof, int data)
 613 +static int tn7dsl_proc_snr_print (struct seq_file *m, int data)
 614  {
 615
 616 -  int len = 0;
 617 -  int limit = count - 80;
 618    int i, j;
 619    int bin = (int) data;
 620    unsigned short *rxSnrPerBin;
 621 @@ -674,95 +675,128 @@ static int tn7dsl_proc_snr_print (char *
 622        break;
 623
 624    default:
 625 -  if(len<=limit)
 626 -        len += sprintf (buf + len, "\nInvalid bin selected Bin%d :\n", bin);
 627 -  return len;
 628 -}
 629 +      seq_printf (m, "\nInvalid bin selected Bin%d :\n", bin);
 630 +      return 0;
 631 +  }
 632
 633 -  if(len<=limit)
 634 -    len += sprintf (buf + len, "\nAR7 DSL Modem Rx SNR Per Bin for Bin%d :\n", bin);
 635 +  seq_printf (m, "\nAR7 DSL Modem Rx SNR Per Bin for Bin%d :\n", bin);
 636
 637    for (i=0; i<pIhw->AppData.max_ds_tones/16; i++)
 638    {
 639      for(j=0;j<16;j++)
 640      {
 641 -      if(len <=limit)
 642 -        len +=
 643 -          sprintf (buf + len, "%04x ",
 644 +      seq_printf (m, "%04x ",
 645                     (unsigned short) rxSnrPerBin[i * 16 + j]);
 646 -  }
 647 -      if(len <=limit)
 648 -        len += sprintf(buf+len, "\n");
 649      }
 650 +      seq_printf(m, "\n");
 651 +  }
 652
 653 -  return len;
 654 +  return 0;
 655  }
 656
 657
 658  //@Added SNR per bin info per customer request. 05-14-2004
 659 -int tn7dsl_proc_snr0 (char *buf, char **start, off_t offset, int count,
 660 -                      int *eof, void *data)
 661 +static int tn7dsl_proc_snr0 (struct seq_file *m, void *data)
 662      {
 663 -  return tn7dsl_proc_snr_print(buf, count, eof, 0);
 664 +  return tn7dsl_proc_snr_print(m, 0);
 665      }
 666
 667 -int tn7dsl_proc_snr1 (char *buf, char **start, off_t offset, int count,
 668 -                      int *eof, void *data)
 669 +static int tn7dsl_proc_snr0_open(struct inode *inode, struct file *file)
 670  {
 671 -  return tn7dsl_proc_snr_print(buf, count, eof, 1);
 672 +       return single_open(file, tn7dsl_proc_snr0, PDE_DATA(inode));
 673 +}
 674 +
 675 +struct file_operations tn7dsl_proc_snr0_fops = {
 676 +       .owner          = THIS_MODULE,
 677 +       .open           = tn7dsl_proc_snr0_open,
 678 +       .read           = seq_read,
 679 +       .llseek         = seq_lseek,
 680 +       .release        = single_release,
 681 +};
 682 +
 683 +static int tn7dsl_proc_snr1 (struct seq_file *m, void *data)
 684 +{
 685 +  return tn7dsl_proc_snr_print(m, 1);
 686    }
 687
 688 -int tn7dsl_proc_snr2 (char *buf, char **start, off_t offset, int count,
 689 -                      int *eof, void *data)
 690 +static int tn7dsl_proc_snr1_open(struct inode *inode, struct file *file)
 691  {
 692 -  return tn7dsl_proc_snr_print(buf, count, eof, 2);
 693 +       return single_open(file, tn7dsl_proc_snr1, PDE_DATA(inode));
 694  }
 695
 696 +struct file_operations tn7dsl_proc_snr1_fops = {
 697 +       .owner          = THIS_MODULE,
 698 +       .open           = tn7dsl_proc_snr1_open,
 699 +       .read           = seq_read,
 700 +       .llseek         = seq_lseek,
 701 +       .release        = single_release,
 702 +};
 703 +
 704 +static int tn7dsl_proc_snr2 (struct seq_file *m, void *data)
 705 +{
 706 +  return tn7dsl_proc_snr_print(m, 2);
 707 +}
 708 +
 709 +static int tn7dsl_proc_snr2_open(struct inode *inode, struct file *file)
 710 +{
 711 +       return single_open(file, tn7dsl_proc_snr2, PDE_DATA(inode));
 712 +}
 713 +
 714 +struct file_operations tn7dsl_proc_snr2_fops = {
 715 +       .owner          = THIS_MODULE,
 716 +       .open           = tn7dsl_proc_snr2_open,
 717 +       .read           = seq_read,
 718 +       .llseek         = seq_lseek,
 719 +       .release        = single_release,
 720 +};
 721 +
 722  //@Added bit allocation table per customer request. 05-14-2004
 723 -int tn7dsl_proc_bit_allocation (char *buf, char **start, off_t offset,
 724 -                                int count, int *eof, void *data)
 725 +static int tn7dsl_proc_bit_allocation (struct seq_file *m, void *data)
 726  {
 727
 728 -  int len = 0;
 729 -  int limit = count - 80;
 730    int i, j;
 731
 732 -  if(len<=limit)
 733 -    len += sprintf(buf+len, "\nAR7 DSL Modem US Bit Allocation:");
 734 +  seq_printf(m, "\nAR7 DSL Modem US Bit Allocation:");
 735
 736    for(i=0; i<pIhw->AppData.max_us_tones; i++)
 737      {
 738      if (!(i%16))
 739      {
 740 -      if(len <=limit)
 741 -        len += sprintf(buf+len, "\n");
 742 +        seq_printf(m, "\n");
 743      }
 744 -    if(len <=limit)
 745 -      len +=
 746 -        sprintf (buf + len, "%02x ",
 747 -                 (unsigned char) pIhw->AppData.BitAllocTblUstrm[i]);
 748 +    seq_printf (m, "%02x ",
 749 +                (unsigned char) pIhw->AppData.BitAllocTblUstrm[i]);
 750    }
 751
 752 -  if(len<=limit)
 753 -    len += sprintf(buf+len, "\n\nAR7 DSL Modem DS Bit Allocation:\n");
 754 +  seq_printf(m, "\n\nAR7 DSL Modem DS Bit Allocation:\n");
 755
 756    for (i=0; i<pIhw->AppData.max_ds_tones/16; i++)
 757    {
 758      for(j=0;j<16;j++)
 759      {
 760 -      if(len <=limit)
 761 -        len +=
 762 -          sprintf (buf + len, "%02x ",
 763 -                   (unsigned char) pIhw->AppData.BitAllocTblDstrm[i * 16 +
 764 -                                                                  j]);
 765 +      seq_printf (m, "%02x ",
 766 +                  (unsigned char) pIhw->AppData.BitAllocTblDstrm[i * 16 +
 767 +                                                                 j]);
 768      }
 769 -    if(len <=limit)
 770 -        len += sprintf(buf+len, "\n");
 771 +    seq_printf(m, "\n");
 772    }
 773
 774 -  return len;
 775 +  return 0;
 776 +}
 777 +
 778 +int tn7dsl_proc_bit_allocation_open(struct inode *inode, struct file *file)
 779 +{
 780 +       return single_open(file, tn7dsl_proc_bit_allocation, PDE_DATA(inode));
 781  }
 782
 783 +struct file_operations tn7dsl_proc_bit_allocation_fops = {
 784 +       .owner          = THIS_MODULE,
 785 +       .open           = tn7dsl_proc_bit_allocation_open,
 786 +       .read           = seq_read,
 787 +       .llseek         = seq_lseek,
 788 +       .release        = single_release,
 789 +};
 790 +
 791  #ifndef NO_ACT
 792  int tn7dsl_proc_ds_noise(char* buf, char **start, off_t offset, int count,
 793                   int *eof, void *data)
 794 @@ -825,59 +859,48 @@ static char *pUnknown= "Unknown";
 795  #ifdef ADV_DIAG_STATS //CQ10275, CQ10449
 796  //UR8_MERGE_START CQ10449 Jack Zhang
 797
 798 -static int proc_adv_stats_header(char* buf, int limit);
 799 +static int proc_adv_stats_header(struct seq_file *m);
 800
 801 -int tn7dsl_proc_adv_stats(char* buf, char **start, off_t offset, int count,
 802 -                 int *eof, void *data)
 803 +static int tn7dsl_proc_adv_stats(struct seq_file *m, void *data)
 804  {
 805
 806 -  int len = 0;
 807 -  int limit = count - 80;
 808    //char *cp = buf + offset;
 809    char *cp = buf;
 810    int i = 0;
 811    int strt = 32;
 812 -  static int ctr = 0;
 813
 814  //  printk("proc_adv_stats: buf=0x%X, ctr=%d, offset=%d, count=%d, eof=%d\n",
 815  //             (unsigned int)buf, ctr, offset, count, *eof);
 816 -  if( ctr == 0)
 817 -  {
 818 -    len = proc_adv_stats_header( cp, limit);
 819 -
 820 -    if( len<=limit)
 821 -      len += sprintf(cp+len, "\n\tBin No.\tBits:\tMargin:\tSNR\n");
 822 -  }
 823 -  else
 824 -  {
 825 -    strt = ctr;
 826 -  }
 827 -
 828 +  proc_adv_stats_header(m);
 829 +
 830 +  seq_printf(m, "\n\tBin No.\tBits:\tMargin:\tSNR\n");
 831 +
 832    for( i =strt; i<512; i++)
 833    {
 834 -    if(len<=limit)
 835 -    {
 836 -      len += sprintf(cp+len, "\t%u\t%u\t%u\t%d\n", i,
 837 +    seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
 838                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
 839                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
 840                      (int)pIhw->AppData.rxSnrPerBin0[i]);
 841 -    }
 842 -    else
 843 -    {
 844 -      ctr = i;
 845 -      //*eof = 0;
 846 -      *(cp + len) = '\0';
 847 -      printk("proc_adv_stats - return: ctr=%d, len=%d\n", ctr, len);
 848 -      return len;
 849 -    }
 850    }
 851 -  ctr = 0;
 852 -  *eof = 1;
 853    printk("proc_adv_stats - return: ctr=%d, len=%d\n", ctr, len);
 854 -  return len;
 855 +  return 0;
 856 +}
 857 +
 858 +
 859 +static int tn7dsl_proc_adv_stats_open(struct inode *inode, struct file *file)
 860 +{
 861 +       return single_open(file, tn7dsl_proc_adv_stats, PDE_DATA(inode));
 862  }
 863
 864 -static int proc_adv_stats_header(char* buf, int limit)
 865 +struct file_operations tn7dsl_proc_adv_stats_fops = {
 866 +       .owner          = THIS_MODULE,
 867 +       .open           = tn7dsl_proc_adv_stats_open,
 868 +       .read           = seq_read,
 869 +       .llseek         = seq_lseek,
 870 +       .release        = single_release,
 871 +};
 872 +
 873 +static int proc_adv_stats_header(struct seq_file *m)
 874  {
 875    int len = 0;
 876    int i = 0;
 877 @@ -886,66 +909,53 @@ static int proc_adv_stats_header(char* b
 878     */
 879
 880    dslhal_api_gatherStatistics(pIhw);
 881 -  if(len<=limit)
 882 -    len += sprintf(buf+len, "\nAR7 DSL Modem Advanced Statistics:\n");
 883 +  seq_printf(m, "\nAR7 DSL Modem Advanced Statistics:\n");
 884
 885 -  if(len<=limit)
 886 +  if(pIhw->lConnected != 1)
 887    {
 888 -    if(pIhw->lConnected != 1)
 889 -    {
 890 -      pIhw->AppData.USConRate = 0;
 891 -      pIhw->AppData.DSConRate = 0;
 892 -    }
 893 -    len +=
 894 -      sprintf (buf + len,
 895 +    pIhw->AppData.USConRate = 0;
 896 +    pIhw->AppData.DSConRate = 0;
 897 +  }
 898 +  seq_printf (m,
 899                 "\t[Connection Rate]\tUS:\t%u\tDS:\t%u\n",
 900                     (unsigned int)pIhw->AppData.USConRate,
 901                     (unsigned int)pIhw->AppData.DSConRate );
 902    }
 903 -  if(len<=limit)
 904  //  UR8_MERGE_START CQ11054   Jack Zhang
 905 +  if (dslhal_api_getHighPrecision())
 906    {
 907 -    if (dslhal_api_getHighPrecision())
 908 -    {
 909 -      len +=
 910 -        sprintf (buf + len, "\t[Margin]\tUS:\t%d.%u\tDS:\t\t%d.%u\n",
 911 -                   gInt(pIhw->AppData.usMargin), gDot1(pIhw->AppData.usMargin),
 912 -                   gInt(pIhw->AppData.dsMargin), gDot1(pIhw->AppData.dsMargin));
 913 -    }
 914 -    else
 915 -    {
 916 -      len +=
 917 -        sprintf (buf + len, "\t[Margin]\tUS:\t%u\tDS:\t\t%u\n",
 918 -                   (unsigned int)pIhw->AppData.usMargin,
 919 -                   (unsigned int)pIhw->AppData.dsMargin/2 );
 920 -    }
 921 +    seq_printf (m, "\t[Margin]\tUS:\t%d.%u\tDS:\t\t%d.%u\n",
 922 +                 gInt(pIhw->AppData.usMargin), gDot1(pIhw->AppData.usMargin),
 923 +                 gInt(pIhw->AppData.dsMargin), gDot1(pIhw->AppData.dsMargin));
 924 +  }
 925 +  else
 926 +  {
 927 +    seq_printf (m, "\t[Margin]\tUS:\t%u\tDS:\t\t%u\n",
 928 +                 (unsigned int)pIhw->AppData.usMargin,
 929 +                 (unsigned int)pIhw->AppData.dsMargin/2 );
 930    }
 931  //  UR8_MERGE_END   CQ11054*
 932
 933    /*
 934     * Downstream/Upstream Interleaved Errors
 935     */
 936 -  if(len<=limit)
 937 -    len += sprintf(buf+len, "\t[Interleave path] US (TX):\tCRC: \t%u\tFEC: \t%u\n",
 938 +  seq_printf(m, "\t[Interleave path] US (TX):\tCRC: \t%u\tFEC: \t%u\n",
 939                     (unsigned int)pIhw->AppData.usICRC_errors,
 940                     (unsigned int)pIhw->AppData.usIFEC_errors);
 941 -  if(len<=limit)
 942 -    len += sprintf(buf+len, "\t[Interleave path] DS (RX):\tCRC: \t%u\tFEC: \t%u\n",
 943 +  seq_printf(m, "\t[Interleave path] DS (RX):\tCRC: \t%u\tFEC: \t%u\n",
 944                     (unsigned int)pIhw->AppData.dsICRC_errors,
 945                     (unsigned int)pIhw->AppData.dsIFEC_errors);
 946    /*
 947     * Upstream/Downstream Fast Errors
 948     */
 949 -  if(len<=limit)
 950 -    len += sprintf(buf+len, "\t[Fast path] US (TX):  \tCRC: \t%u\tFEC: \t%u\n",
 951 +  seq_printf(m, "\t[Fast path] US (TX):  \tCRC: \t%u\tFEC: \t%u\n",
 952                     (unsigned int)pIhw->AppData.usFCRC_errors,
 953                     (unsigned int)pIhw->AppData.usFFEC_errors);
 954 -  if(len<=limit)
 955 -    len += sprintf(buf+len, "\t[Fast path] DS (RX):\tCRC: \t%u\tFEC: \t%u\n",
 956 +  seq_printf(m, "\t[Fast path] DS (RX):\tCRC: \t%u\tFEC: \t%u\n",
 957                     (unsigned int)pIhw->AppData.dsFCRC_errors,
 958                     (unsigned int)pIhw->AppData.dsFFEC_errors);
 959 -
 960 -  return len;
 961 +
 962 +  return 0;
 963  }
 964
 965  static int getDiagDisplayMode()
 966 @@ -968,29 +978,24 @@ static int getDiagDisplayMode()
 967      ret = 2;
 968    return ret;
 969  }
 970 -int tn7dsl_proc_adv_stats1(char* buf, char **start, off_t offset, int count,
 971 -                 int *eof, void *data)
 972 +int tn7dsl_proc_adv_stats1(struct seq_file *m, void *data)
 973  {
 974
 975 -  int len = 0;
 976 -  int limit = count - 80;
 977    int i;
 978    int mode = 0;  //mode = 0 => ADSL1 or ADSL2 & 2+
 979    unsigned char SNRpsds[512];
 980    int n;
 981
 982 -  len = proc_adv_stats_header( buf+len, limit);
 983 +  proc_adv_stats_header( m);
 984    mode = getDiagDisplayMode();
 985
 986 -  if(len<=limit)
 987 -    len += sprintf(buf+len, "\tBin No.\tBits:\tMargin:\tSNR (Part 1 of 3)\n");
 988 -
 989 +  seq_printf(m, "\tBin No.\tBits:\tMargin:\tSNR (Part 1 of 3)\n");
 990 +
 991    if(mode==1) //ADSL1
 992    {
 993    for( i =32; i<128; i++)
 994    {
 995 -    if(len<=limit)
 996 -      len += sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i,
 997 +    seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
 998                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
 999                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
1000                      (int)pIhw->AppData.rxSnrPerBin0[i]);
1001 @@ -1001,26 +1006,34 @@ int tn7dsl_proc_adv_stats1(char* buf, ch
1002      if (dslhal_api_getSNRpsds(pIhw, SNRpsds, 1))
1003      {
1004        dgprintf(4, "dslhal_api_getSNRpsds failed!\n");
1005 -      return len;
1006 +      return -EIO;
1007      }
1008      for( i =32; i<128; i++)
1009      {
1010 -      if(len<=limit)
1011 -          len += sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i,
1012 +      seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
1013                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
1014                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
1015                      (i<pIhw->AppData.max_ds_tones)?(unsigned char)SNRpsds[i]:0);
1016      }
1017    }
1018 -  return len;
1019 +  return 0;
1020  }
1021
1022 -int tn7dsl_proc_adv_stats2(char* buf, char **start, off_t offset, int count,
1023 -                 int *eof, void *data)
1024 +static int tn7dsl_proc_adv_stats1_open(struct inode *inode, struct file *file)
1025  {
1026 +       return single_open(file, tn7dsl_proc_adv_stats1, PDE_DATA(inode));
1027 +}
1028
1029 -  int len = 0;
1030 -  int limit = count - 80;
1031 +struct file_operations tn7dsl_proc_adv_stats1_fops = {
1032 +       .owner          = THIS_MODULE,
1033 +       .open           = tn7dsl_proc_adv_stats1_open,
1034 +       .read           = seq_read,
1035 +       .llseek         = seq_lseek,
1036 +       .release        = single_release,
1037 +};
1038 +
1039 +int tn7dsl_proc_adv_stats2(struct seq_file *m, void *data)
1040 +{
1041    int i;
1042    int mode = 0;  //mode = 0 => ADSL1 or ADSL2 & 2+
1043    unsigned char SNRpsds[512];
1044 @@ -1030,12 +1043,10 @@ int tn7dsl_proc_adv_stats2(char* buf, ch
1045    if( mode==1) //ADSL1
1046    {
1047    dslhal_api_gatherStatistics(pIhw);
1048 -  if(len<=limit)
1049 -      len += sprintf(buf+len, "\tBin No.\tBits:\tMargin:\tSNR (Part 2 of 3):\n");
1050 +    seq_printf(m, "\tBin No.\tBits:\tMargin:\tSNR (Part 2 of 3):\n");
1051      for( i =128; i<320; i++)
1052      {
1053 -  if(len<=limit)
1054 -        len += sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i,
1055 +      seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
1056                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
1057                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
1058                      (int)pIhw->AppData.rxSnrPerBin0[i]);
1059 @@ -1046,26 +1057,35 @@ int tn7dsl_proc_adv_stats2(char* buf, ch
1060      if (dslhal_api_getSNRpsds(pIhw, SNRpsds, 1))
1061      {
1062        dgprintf(4, "dslhal_api_getSNRpsds failed!\n");
1063 -      return len;
1064 +      return -EIO;
1065      }
1066    for( i =128; i<320; i++)
1067    {
1068 -    if(len<=limit)
1069 -      len += sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i,
1070 +    seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
1071                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
1072                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
1073                      (i<pIhw->AppData.max_ds_tones)?(unsigned char)SNRpsds[i]:0);
1074      }
1075    }
1076 -  return len;
1077 +  return 0;
1078  }
1079
1080 -int tn7dsl_proc_adv_stats3(char* buf, char **start, off_t offset, int count,
1081 -                 int *eof, void *data)
1082 +static int tn7dsl_proc_adv_stats2_open(struct inode *inode, struct file *file)
1083 +{
1084 +       return single_open(file, tn7dsl_proc_adv_stats2, PDE_DATA(inode));
1085 +}
1086 +
1087 +struct file_operations tn7dsl_proc_adv_stats2_fops = {
1088 +       .owner          = THIS_MODULE,
1089 +       .open           = tn7dsl_proc_adv_stats2_open,
1090 +       .read           = seq_read,
1091 +       .llseek         = seq_lseek,
1092 +       .release        = single_release,
1093 +};
1094 +
1095 +int tn7dsl_proc_adv_stats3(struct seq_file *m, void *data)
1096  {
1097
1098 -  int len = 0;
1099 -  int limit = count - 80;
1100    int i;
1101    int mode = 0;  //mode = 0 => ADSL1 or ADSL2 & 2+
1102    unsigned char SNRpsds[512];
1103 @@ -1075,12 +1095,10 @@ int tn7dsl_proc_adv_stats3(char* buf, ch
1104    if( mode==1) //ADSL1
1105    {
1106    dslhal_api_gatherStatistics(pIhw);
1107 -  if(len<=limit)
1108 -      len += sprintf(buf+len, "\tBin No.\tBits:\tMargin:\tSNR (Part 3 of 3):\n");
1109 +    seq_printf(m, "\tBin No.\tBits:\tMargin:\tSNR (Part 3 of 3):\n");
1110      for( i =320; i<512; i++)
1111      {
1112 -  if(len<=limit)
1113 -        len += sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i,
1114 +      seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
1115                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
1116                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
1117                      (int)pIhw->AppData.rxSnrPerBin0[i]);
1118 @@ -1091,283 +1109,287 @@ int tn7dsl_proc_adv_stats3(char* buf, ch
1119      if (dslhal_api_getSNRpsds(pIhw, SNRpsds, 1))
1120      {
1121        dgprintf(4, "dslhal_api_getSNRpsds failed!\n");
1122 -      return len;
1123 +      return -EIO;
1124      }
1125    for( i =320; i<512; i++)
1126    {
1127 -    if(len<=limit)
1128 -      len += sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i,
1129 +    seq_printf(m, "\t%u\t%u\t%u\t%d\n", i,
1130                      (unsigned int)pIhw->AppData.BitAllocTblDstrm[i],
1131                      (unsigned int)pIhw->AppData.marginTblDstrm[i],
1132                      (i<pIhw->AppData.max_ds_tones)?(unsigned char)SNRpsds[i]:0);
1133      }
1134    }
1135 -  if(len<=limit)
1136 -    len += sprintf(buf+len, "[End of Stats]\n");
1137 -  return len;
1138 +  seq_printf(m, "[End of Stats]\n");
1139 +  return 0;
1140  }
1141 -//UR8_MERGE_END  CQ10449
1142 -//UR8_MERGE_START CQ10682   Jack Zhang
1143 -int tn7dsl_proc_dbg_cmsgs(char* buf, char **start, off_t offset, int count,
1144 -                 int *eof, void *data)
1145 +
1146 +static int tn7dsl_proc_adv_stats3_open(struct inode *inode, struct file *file)
1147  {
1148 +       return single_open(file, tn7dsl_proc_adv_stats3, PDE_DATA(inode));
1149 +}
1150
1151 -  int len = 0;
1152 -  int limit = count - 80;
1153 +struct file_operations tn7dsl_proc_adv_stats3_fops = {
1154 +       .owner          = THIS_MODULE,
1155 +       .open           = tn7dsl_proc_adv_stats3_open,
1156 +       .read           = seq_read,
1157 +       .llseek         = seq_lseek,
1158 +       .release        = single_release,
1159 +};
1160
1161 +//UR8_MERGE_END  CQ10449
1162 +//UR8_MERGE_START CQ10682   Jack Zhang
1163 +int tn7dsl_proc_dbg_cmsgs(struct seq_file *m, void *data)
1164 +{
1165    int rc=0;
1166
1167    dslhal_api_gatherStatistics(pIhw);
1168
1169 -  if(len<=limit)
1170 -    len += sprintf(buf+len, "Training Messages (C-Msgs 1-5)..\n");
1171 +  seq_printf(m, "Training Messages (C-Msgs 1-5)..\n");
1172
1173 -  if(len<=limit)
1174 -    len += sprintf(buf+len, "ADSL2 DELT C-Msg1Ld \t Message Length:%d\n",
1175 +  seq_printf(m, "ADSL2 DELT C-Msg1Ld \t Message Length:%d\n",
1176                              pIhw->adsl2DiagnosticMessages.cMsg1LdLen);
1177    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.cMsg1LdLen;rc++)
1178    {
1179 -    if(len<=limit)
1180 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg1Ld[rc]);
1181 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg1Ld[rc]);
1182      if(rc!=0 && (rc%16==0))
1183 -      if(len<=limit)
1184 -        len += sprintf(buf+len, "\n");
1185 +      seq_printf(m, "\n");
1186    }
1187 -  if(len<=limit)
1188 -    len += sprintf(buf+len, "\nADSL2 DELT C-Msg2Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg2LdLen);
1189 +  seq_printf(m, "\nADSL2 DELT C-Msg2Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg2LdLen);
1190
1191    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.cMsg2LdLen;rc++)
1192    {
1193 -    if(len<=limit)
1194 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg2Ld[rc]);
1195 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg2Ld[rc]);
1196      if(rc!=0 && (rc%16==0))
1197 -      if(len<=limit)
1198 -        len += sprintf(buf+len, "\n");
1199 +      seq_printf(m, "\n");
1200    }
1201
1202 -  if(len<=limit)
1203 -    len += sprintf(buf+len, "\nADSL2 DELT C-Msg3Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg3LdLen);
1204 +  seq_printf(m, "\nADSL2 DELT C-Msg3Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg3LdLen);
1205
1206    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.cMsg3LdLen;rc++)
1207    {
1208 -    if(len<=limit)
1209 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg3Ld[rc]);
1210 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg3Ld[rc]);
1211      if(rc!=0 && (rc%16==0))
1212 -      if(len<=limit)
1213 -        len += sprintf(buf+len, "\n");
1214 +      seq_printf(m, "\n");
1215    }
1216
1217 -  if(len<=limit)
1218 -    len += sprintf(buf+len, "\nADSL2 DELT C-Msg4Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg4LdLen);
1219 +  seq_printf(m, "\nADSL2 DELT C-Msg4Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg4LdLen);
1220
1221    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.cMsg4LdLen;rc++)
1222    {
1223 -    if(len<=limit)
1224 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg4Ld[rc]);
1225 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg4Ld[rc]);
1226      if(rc!=0 && (rc%16==0))
1227 -      if(len<=limit)
1228 -        len += sprintf(buf+len, "\n");
1229 +      seq_printf(m, "\n");
1230    }
1231
1232 -  if(len<=limit)
1233 -    len += sprintf(buf+len, "\nADSL2 DELT C-Msg5Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg5LdLen);
1234 +  seq_printf(m, "\nADSL2 DELT C-Msg5Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.cMsg5LdLen);
1235
1236    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.cMsg5LdLen;rc++)
1237    {
1238 -    if(len<=limit)
1239 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg5Ld[rc]);
1240 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.cMsg5Ld[rc]);
1241      if(rc!=0 && (rc%16==0))
1242 -      if(len<=limit)
1243 -        len += sprintf(buf+len, "\n");
1244 +      seq_printf(m, "\n");
1245    }
1246 -  if(len<=limit)
1247 -    len += sprintf(buf+len, "\n");
1248 -  return len;
1249 +  seq_printf(m, "\n");
1250 +  return 0;
1251  }
1252
1253 -int tn7dsl_proc_dbg_rmsgs1(char* buf, char **start, off_t offset, int count,
1254 -                 int *eof, void *data)
1255 +static int tn7dsl_proc_dbg_cmsgs_open(struct inode *inode, struct file *file)
1256  {
1257 +       return single_open(file, tn7dsl_proc_dbg_cmsgs, PDE_DATA(inode));
1258 +}
1259 +
1260 +struct file_operations tn7dsl_proc_dbg_cmsgs_fops = {
1261 +       .owner          = THIS_MODULE,
1262 +       .open           = tn7dsl_proc_dbg_cmsgs_open,
1263 +       .read           = seq_read,
1264 +       .llseek         = seq_lseek,
1265 +       .release        = single_release,
1266 +};
1267
1268 -  int len = 0;
1269 -  int limit = count - 80;
1270 +
1271 +int tn7dsl_proc_dbg_rmsgs1(struct seq_file *m, void *data)
1272 +{
1273
1274    int rc=0;
1275
1276    dslhal_api_gatherStatistics(pIhw);
1277
1278 -  if(len<=limit)
1279 -    len += sprintf(buf+len, "Training Messages (R-Msgs 1-3)..\n");
1280 +  seq_printf(m, "Training Messages (R-Msgs 1-3)..\n");
1281
1282 -  if(len<=limit)
1283 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg1Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsg1LdLen);
1284 +  seq_printf(m, "\nADSL2 DELT R-Msg1Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsg1LdLen);
1285
1286    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsg1LdLen;rc++)
1287    {
1288 -    if(len<=limit)
1289 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg1Ld[rc]);
1290 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg1Ld[rc]);
1291      if(rc!=0 && (rc%16==0))
1292 -      if(len<=limit)
1293 -        len += sprintf(buf+len, "\n");
1294 +      seq_printf(m, "\n");
1295    }
1296
1297 -  if(len<=limit)
1298 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg2Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1299 +  seq_printf(m, "\nADSL2 DELT R-Msg2Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1300
1301    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1302    {
1303 -    if(len<=limit)
1304 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg2Ld[rc]);
1305 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg2Ld[rc]);
1306      if(rc!=0 && (rc%16==0))
1307 -      if(len<=limit)
1308 -        len += sprintf(buf+len, "\n");
1309 +      seq_printf(m, "\n");
1310    }
1311
1312 -  if(len<=limit)
1313 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg3Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1314 +  seq_printf(m, "\nADSL2 DELT R-Msg3Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1315    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1316    {
1317 -    if(len<=limit)
1318 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg3Ld[rc]);
1319 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg3Ld[rc]);
1320      if(rc!=0 && (rc%16==0))
1321 -      if(len<=limit)
1322 -        len += sprintf(buf+len, "\n");
1323 +      seq_printf(m, "\n");
1324    }
1325 -  if(len<=limit)
1326 -    len += sprintf(buf+len, "\n");
1327 -  return len;
1328 +  seq_printf(m, "\n");
1329 +  return 0;
1330  }
1331
1332 -int tn7dsl_proc_dbg_rmsgs2(char* buf, char **start, off_t offset, int count,
1333 -                 int *eof, void *data)
1334 +static int tn7dsl_proc_dbg_rmsgs1_open(struct inode *inode, struct file *file)
1335  {
1336 +       return single_open(file, tn7dsl_proc_dbg_rmsgs1, PDE_DATA(inode));
1337 +}
1338
1339 -  int len = 0;
1340 -  int limit = count - 80;
1341 +struct file_operations tn7dsl_proc_dbg_rmsgs1_fops = {
1342 +       .owner          = THIS_MODULE,
1343 +       .open           = tn7dsl_proc_dbg_rmsgs1_open,
1344 +       .read           = seq_read,
1345 +       .llseek         = seq_lseek,
1346 +       .release        = single_release,
1347 +};
1348 +
1349 +
1350 +int tn7dsl_proc_dbg_rmsgs2(struct seq_file *m, void *data)
1351 +{
1352
1353    int rc=0;
1354
1355    dslhal_api_gatherStatistics(pIhw);
1356
1357 -  if(len<=limit)
1358 -    len += sprintf(buf+len, "Training Messages (R-Msgs 4-5)..\n");
1359 +  seq_printf(m, "Training Messages (R-Msgs 4-5)..\n");
1360
1361 -  if(len<=limit)
1362 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg4Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1363 +  seq_printf(m, "\nADSL2 DELT R-Msg4Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1364    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1365    {
1366 -    if(len<=limit)
1367 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg4Ld[rc]);
1368 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg4Ld[rc]);
1369      if(rc!=0 && (rc%16==0))
1370 -      if(len<=limit)
1371 -        len += sprintf(buf+len, "\n");
1372 +      len += sprintf(m, "\n");
1373    }
1374
1375 -  if(len<=limit)
1376 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg5Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1377 +  seq_printf(m, "\nADSL2 DELT R-Msg5Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1378    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1379    {
1380 -    if(len<=limit)
1381 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg5Ld[rc]);
1382 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg5Ld[rc]);
1383      if(rc!=0 && (rc%16==0))
1384 -      if(len<=limit)
1385 -        len += sprintf(buf+len, "\n");
1386 +      seq_printf(m, "\n");
1387    }
1388
1389 -  if(len<=limit)
1390 -    len += sprintf(buf+len, "\n");
1391 -  return len;
1392 +  seq_printf(m, "\n");
1393 +  return 0;
1394  }
1395
1396 -int tn7dsl_proc_dbg_rmsgs3(char* buf, char **start, off_t offset, int count,
1397 -                 int *eof, void *data)
1398 +static int tn7dsl_proc_dbg_rmsgs2_open(struct inode *inode, struct file *file)
1399  {
1400 +       return single_open(file, tn7dsl_proc_dbg_rmsgs2, PDE_DATA(inode));
1401 +}
1402
1403 -  int len = 0;
1404 -  int limit = count - 80;
1405 +struct file_operations _fops = {
1406 +       .owner          = THIS_MODULE,
1407 +       .open           = tn7dsl_proc_dbg_rmsgs2_open,
1408 +       .read           = seq_read,
1409 +       .llseek         = seq_lseek,
1410 +       .release        = single_release,
1411 +};
1412 +
1413 +int tn7dsl_proc_dbg_rmsgs3(struct seq_file *m, void *data)
1414 +{
1415
1416    int rc=0;
1417
1418    dslhal_api_gatherStatistics(pIhw);
1419
1420 -  if(len<=limit)
1421 -    len += sprintf(buf+len, "Training Messages (R-Msgs 6-7)..\n");
1422 +  seq_printf(m, "Training Messages (R-Msgs 6-7)..\n");
1423
1424 -  if(len<=limit)
1425 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg6Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1426 +  seq_printf(m, "\nADSL2 DELT R-Msg6Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1427    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1428    {
1429 -    if(len<=limit)
1430 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg6Ld[rc]);
1431 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg6Ld[rc]);
1432      if(rc!=0 && (rc%16==0))
1433 -      if(len<=limit)
1434 -        len += sprintf(buf+len, "\n");
1435 +      seq_printf(m, "\n");
1436    }
1437 -  if(len<=limit)
1438 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg7Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1439 +  seq_printf(m, "\nADSL2 DELT R-Msg7Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1440    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1441    {
1442 -    if(len<=limit)
1443 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg7Ld[rc]);
1444 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg7Ld[rc]);
1445      if(rc!=0 && (rc%16==0))
1446 -      if(len<=limit)
1447 -        len += sprintf(buf+len, "\n");
1448 +      seq_printf(m, "\n");
1449    }
1450 -  if(len<=limit)
1451 -    len += sprintf(buf+len, "\n");
1452 +  seq_printf(m, "\n");
1453
1454 -  return len;
1455 +  return 0;
1456  }
1457
1458 -int tn7dsl_proc_dbg_rmsgs4(char* buf, char **start, off_t offset, int count,
1459 -                 int *eof, void *data)
1460 +static int tn7dsl_proc_dbg_rmsgs3_open(struct inode *inode, struct file *file)
1461  {
1462 +       return single_open(file, tn7dsl_proc_dbg_rmsgs3, PDE_DATA(inode));
1463 +}
1464
1465 -  int len = 0;
1466 -  int limit = count - 80;
1467 +struct file_operations tn7dsl_proc_dbg_rmsgs3_fops = {
1468 +       .owner          = THIS_MODULE,
1469 +       .open           = tn7dsl_proc_dbg_rmsgs3_open,
1470 +       .read           = seq_read,
1471 +       .llseek         = seq_lseek,
1472 +       .release        = single_release,
1473 +};
1474 +
1475 +int tn7dsl_proc_dbg_rmsgs4(struct seq_file *m, void *data)
1476 +{
1477
1478    int rc=0;
1479
1480    dslhal_api_gatherStatistics(pIhw);
1481
1482 -  if(len<=limit)
1483 -    len += sprintf(buf+len, "Training Messages (R-Msgs 8-9)..\n");
1484 +  seq_printf(m, "Training Messages (R-Msgs 8-9)..\n");
1485
1486 -  if(len<=limit)
1487 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg8Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1488 +  seq_printf(m, "\nADSL2 DELT R-Msg8Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1489    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1490    {
1491 -    if(len<=limit)
1492 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg8Ld[rc]);
1493 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg8Ld[rc]);
1494      if(rc!=0 && (rc%16==0))
1495 -      if(len<=limit)
1496 -        len += sprintf(buf+len, "\n");
1497 +      seq_printf(m, "\n");
1498    }
1499
1500 -  if(len<=limit)
1501 -    len += sprintf(buf+len, "\nADSL2 DELT R-Msg9Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1502 +  seq_printf(m, "\nADSL2 DELT R-Msg9Ld \t Message Length:%d\n",pIhw->adsl2DiagnosticMessages.rMsgxLdLen);
1503    for(rc=0;rc<pIhw->adsl2DiagnosticMessages.rMsgxLdLen;rc++)
1504    {
1505 -    if(len<=limit)
1506 -      len += sprintf(buf+len, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg9Ld[rc]);
1507 +    seq_printf(m, "  %02x",(unsigned char)pIhw->adsl2DiagnosticMessages.rMsg9Ld[rc]);
1508      if(rc!=0 && (rc%16==0))
1509 -      if(len<=limit)
1510 -        len += sprintf(buf+len, "\n");
1511 +      seq_printf(m, "\n");
1512    }
1513 -  if(len<=limit)
1514 -    len += sprintf(buf+len, "\n");
1515 +  seq_printf(m, "\n");
1516
1517 -  return len;
1518 +  return 0;
1519 +}
1520 +
1521 +static int tn7dsl_proc_dbg_rmsgs4_open(struct inode *inode, struct file *file)
1522 +{
1523 +       return single_open(file, tn7dsl_proc_dbg_rmsgs4, PDE_DATA(inode));
1524  }
1525 +
1526 +struct file_operations tn7dsl_proc_dbg_rmsgs4_fops = {
1527 +       .owner          = THIS_MODULE,
1528 +       .open           = tn7dsl_proc_dbg_rmsgs4_open,
1529 +       .read           = seq_read,
1530 +       .llseek         = seq_lseek,
1531 +       .release        = single_release,
1532 +};
1533 +
1534  //UR8_MERGE_END   CQ10682*
1535  #endif //ADV_DIAG_STATS
1536
1537 -int tn7dsl_proc_stats(char* buf, char **start, off_t offset, int count,
1538 -                 int *eof, void *data)
1539 +static int tn7dsl_proc_stats(struct seq_file *m, void *data)
1540  {
1541
1542 -  int len = 0;
1543 -  int limit = count - 80;
1544    int F4count, F5count;
1545    unsigned int maxRate=0;
1546    unsigned int us_maxRate=0;
1547 @@ -1375,80 +1397,58 @@ int tn7dsl_proc_stats(char* buf, char **
1548    //UR8_MERGE_START CQ10700 Manjula K
1549    struct atm_dev *dev;
1550    Tn7AtmPrivate *priv;
1551 -  dev = (struct atm_dev *)data;
1552 +  int offset[2] = { 32, 0 };
1553 +  unsigned int usBitswap, dsBitswap;
1554 +  dev = (struct atm_dev *)m->private;
1555    priv = (Tn7AtmPrivate *)dev->dev_data;
1556    //UR8_MERGE_END CQ10700
1557
1558 +
1559    /*
1560     * Read Ax5 Stats
1561     */
1562
1563    dslhal_api_gatherStatistics(pIhw);
1564 -  if(len<=limit)
1565 -    len += sprintf(buf+len, "\nAR7 DSL Modem Statistics:\n");
1566 -  if(len<=limit)
1567 -    len += sprintf(buf+len, "--------------------------------\n");
1568 +  seq_printf(m, "\nAR7 DSL Modem Statistics:\n");
1569 +  seq_printf(m, "--------------------------------\n");
1570    /*
1571     * us and ds Connection Rates
1572     */
1573 -  if(len<=limit)
1574 -    len += sprintf(buf+len, "[DSL Modem Stats]\n");
1575 +  seq_printf(m, "[DSL Modem Stats]\n");
1576
1577
1578 -  if(len<=limit)
1579 +  if(pIhw->lConnected != 1)
1580    {
1581 -    if(pIhw->lConnected != 1)
1582 -    {
1583 -      pIhw->AppData.USConRate = 0;
1584 -      pIhw->AppData.DSConRate = 0;
1585 -    }
1586 -    len +=
1587 -      sprintf (buf + len,
1588 -               "\tUS Connection Rate:\t%u\tDS Connection Rate:\t%u\n",
1589 -                   (unsigned int)pIhw->AppData.USConRate,
1590 -                   (unsigned int)pIhw->AppData.DSConRate );
1591 +    pIhw->AppData.USConRate = 0;
1592 +    pIhw->AppData.DSConRate = 0;
1593    }
1594 -  if(len<=limit)
1595 +  seq_printf (m,
1596 +             "\tUS Connection Rate:\t%u\tDS Connection Rate:\t%u\n",
1597 +                 (unsigned int)pIhw->AppData.USConRate,
1598 +                 (unsigned int)pIhw->AppData.DSConRate );
1599  //  UR8_MERGE_START CQ11054   Jack Zhang
1600 -  {
1601 -    if (dslhal_api_getHighPrecision())
1602 -    {
1603 -      len +=
1604 -        sprintf (buf + len, "\tDS Line Attenuation:\t%u.%u\tDS Margin:\t\t%d.%u\n",
1605 +  if (dslhal_api_getHighPrecision())
1606 +    seq_printf (m, "\tDS Line Attenuation:\t%u.%u\tDS Margin:\t\t%d.%u\n",
1607                     gInt(pIhw->AppData.dsLineAttn), gDot1(pIhw->AppData.dsLineAttn),
1608                     gInt(pIhw->AppData.dsMargin), gDot1(pIhw->AppData.dsMargin));
1609 -    }
1610 -    else{
1611 -      len +=
1612 -        sprintf (buf + len, "\tDS Line Attenuation:\t%u\tDS Margin:\t\t%u\n",
1613 +  else
1614 +    seq_printf (m, "\tDS Line Attenuation:\t%u\tDS Margin:\t\t%u\n",
1615                     (unsigned int)pIhw->AppData.dsLineAttn/2,
1616                     (unsigned int)pIhw->AppData.dsMargin/2 );
1617 -    }
1618 -  }
1619  //  UR8_MERGE_END   CQ11054*
1620
1621 -  if(len<=limit)
1622  //  UR8_MERGE_START CQ11054   Jack Zhang
1623 -  {
1624 -    if (dslhal_api_getHighPrecision())
1625 -    {
1626 -      len +=
1627 -        sprintf (buf + len, "\tUS Line Attenuation:\t%u.%u\tUS Margin:\t\t%d.%u\n",
1628 +  if (dslhal_api_getHighPrecision())
1629 +    seq_printf (m, "\tUS Line Attenuation:\t%u.%u\tUS Margin:\t\t%d.%u\n",
1630                     gInt(pIhw->AppData.usLineAttn), gDot1(pIhw->AppData.usLineAttn),
1631                     gInt(pIhw->AppData.usMargin), gDot1(pIhw->AppData.usMargin));
1632 -    }
1633 -    else
1634 -    {
1635 -      len +=
1636 -        sprintf (buf + len, "\tUS Line Attenuation:\t%u\tUS Margin:\t\t%u\n",
1637 +  else
1638 +    seq_printf (m, "\tUS Line Attenuation:\t%u\tUS Margin:\t\t%u\n",
1639                     (unsigned int)pIhw->AppData.usLineAttn/2,
1640                     (unsigned int)pIhw->AppData.usMargin );
1641 -    }
1642 -  }
1643  //  UR8_MERGE_END   CQ11054*
1644
1645 -  if(len<=limit)
1646 -    len += sprintf(buf+len, "\tUS Payload :\t\t%u\tDS Payload:\t\t%u\n",
1647 +  seq_printf(m, "\tUS Payload :\t\t%u\tDS Payload:\t\t%u\n",
1648                      ((unsigned int) pIhw->AppData.usAtm_count[0] +
1649                       (unsigned int) pIhw->AppData.usAtm_count[1]) * 48,
1650                      ((unsigned int) pIhw->AppData.dsGood_count[0] +
1651 @@ -1456,9 +1456,7 @@ int tn7dsl_proc_stats(char* buf, char **
1652    /*
1653     * Superframe Count
1654     */
1655 -  if(len<=limit)
1656 -    len +=
1657 -      sprintf (buf + len,
1658 +  seq_printf (m,
1659                 "\tUS Superframe Cnt :\t%u\tDS Superframe Cnt:\t%u\n",
1660                     (unsigned int)pIhw->AppData.usSuperFrmCnt,
1661                     (unsigned int)pIhw->AppData.dsSuperFrmCnt );
1662 @@ -1466,57 +1464,45 @@ int tn7dsl_proc_stats(char* buf, char **
1663    /*
1664     * US and DS power
1665     */
1666 -  if(len<=limit)
1667 +  if(pIhw->AppData.bState < 5)
1668    {
1669 -    if(pIhw->AppData.bState < 5)
1670 -    {
1671 -      pIhw->AppData.usTxPower = 0;
1672 -      pIhw->AppData.dsTxPower = 0;
1673 -    }
1674 -    len +=
1675 -      sprintf (buf + len,
1676 +    pIhw->AppData.usTxPower = 0;
1677 +    pIhw->AppData.dsTxPower = 0;
1678 +  }
1679 +  seq_printf (m,
1680 +// UR8_MERGE_START - CQ11579 - Jeremy #1
1681                 "\tUS Transmit Power :\t%u\tDS Transmit Power:\t%u\n",
1682                     (unsigned int)pIhw->AppData.usTxPower/256,
1683                     (unsigned int)pIhw->AppData.dsTxPower/256 );
1684 -  }
1685 +// UR8_MERGE_END - CQ11579
1686    /*
1687     * DSL Stats Errors
1688     */
1689 -  if(len<=limit)
1690 -    len += sprintf(buf+len, "\tLOS errors:\t\t%u\tSEF errors:\t\t%u\n",
1691 +  seq_printf(m, "\tLOS errors:\t\t%u\tSEF errors:\t\t%u\n",
1692                     (unsigned int)pIhw->AppData.LOS_errors,
1693                     (unsigned int)pIhw->AppData.SEF_errors );
1694
1695    //UR8_MERGE_START Report_SES Manjula K
1696    //CQ10369
1697 -  if(len<=limit)
1698 -    len += sprintf(buf+len, "\tErrored Seconds:\t%u\tSeverely Err Secs:\t%u\n",
1699 +  seq_printf(m, "\tErrored Seconds:\t%u\tSeverely Err Secs:\t%u\n",
1700                     (unsigned int)pIhw->AppData.erroredSeconds,
1701                     (unsigned int)pIhw->AppData.severelyerrsecs );
1702    //UR8_MERGE_END Report_SES
1703 -
1704 -  if(len<=limit)
1705 -    len += sprintf(buf+len, "\tFrame mode:\t\t%u\tMax Frame mode:\t\t%u\n",
1706 +
1707 +  seq_printf(m, "\tFrame mode:\t\t%u\tMax Frame mode:\t\t%u\n",
1708                     (unsigned int)pIhw->AppData.FrmMode,
1709                     (unsigned int)pIhw->AppData.MaxFrmMode );
1710 -  if(len<=limit)
1711 -    len +=
1712 -      sprintf (buf + len, "\tTrained Path:\t\t%u\tUS Peak Cell Rate:\t%u\n",
1713 +  seq_printf (m, "\tTrained Path:\t\t%u\tUS Peak Cell Rate:\t%u\n",
1714                     (unsigned int)pIhw->AppData.TrainedPath,
1715                     (unsigned int)pIhw->AppData.USConRate*1000/8/53 );
1716 -  if(len<=limit)
1717 -    len +=
1718 -      sprintf (buf + len, "\tTrained Mode:\t\t%u\tSelected Mode:\t\t%u\n",
1719 +  seq_printf (m, "\tTrained Mode:\t\t%u\tSelected Mode:\t\t%u\n",
1720                 (unsigned int) pIhw->AppData.TrainedMode,
1721                 (unsigned int) pIhw->AppData.StdMode);
1722
1723 -  if(len<=limit)
1724 -    len +=
1725 -      sprintf (buf + len, "\tATUC Vendor Code:\t%X\tATUC Revision:\t%u\n",
1726 +  seq_printf (m, "\tATUC Vendor Code:\t%X\tATUC Revision:\t%u\n",
1727                 (unsigned int) pIhw->AppData.atucVendorId,
1728                 pIhw->AppData.atucRevisionNum);
1729 -  if(len<=limit)
1730 -    len += sprintf(buf+len, "\tHybrid Selected:\t%u\tTrellis:\t\t%u\n",
1731 +  seq_printf(m, "\tHybrid Selected:\t%u\tTrellis:\t\t%u\n",
1732                     (unsigned int)pIhw->AppData.currentHybridNum, trellis);
1733
1734    //@Added Maximum attainable bit rate information. 05-14-2004
1735 @@ -1528,12 +1514,12 @@ int tn7dsl_proc_stats(char* buf, char **
1736    }
1737    else
1738    {
1739 -     int offset[2] = {5, 1};
1740 +     int dspOffset[2] = { 5, 1 };
1741       unsigned char rMsgsRA[12];
1742       int numPayloadBytes = 0;
1743
1744      dslhal_api_dspInterfaceRead (pIhw, (unsigned int) pIhw->pmainAddr, 2,
1745 -                                 (unsigned int *) &offset,
1746 +                                 (unsigned int *) &dspOffset,
1747                                   (unsigned char *) &rMsgsRA[0], 12);
1748
1749       maxRate = (unsigned int)pIhw->AppData.DSConRate;
1750 @@ -1549,283 +1535,213 @@ int tn7dsl_proc_stats(char* buf, char **
1751       }
1752    }
1753
1754 -  if(len<=limit)
1755 -    len +=
1756 -      sprintf (buf + len,
1757 +  seq_printf (m,
1758                 "\tShowtime Count:\t\t%u\tDS Max Attainable Bit Rate: %u kbps\n",
1759                     (unsigned int)pIhw->AppData.showtimeCount, maxRate);
1760
1761 -  if(len<=limit)
1762 -  {
1763 -    int offset[2] = {32, 0};
1764 -    unsigned int usBitswap, dsBitswap;
1765 +  tn7dsl_generic_read(2, (unsigned int *)&offset);
1766 +  dsBitswap = dslReg & dslhal_support_byteSwap32(0x000000ff);
1767
1768 -    tn7dsl_generic_read(2, (unsigned int *)&offset);
1769 -    dsBitswap = dslReg & dslhal_support_byteSwap32(0x000000ff);
1770 +  offset[0] = 33;
1771 +  tn7dsl_generic_read(2, (unsigned int *)&offset);
1772 +  usBitswap = dslReg & dslhal_support_byteSwap32(0x000000ff);
1773
1774 -    offset[0] = 33;
1775 -    tn7dsl_generic_read(2, (unsigned int *)&offset);
1776 -    usBitswap = dslReg & dslhal_support_byteSwap32(0x000000ff);
1777 -
1778 -    if(pIhw->AppData.dsl_modulation > 5)
1779 -      len +=
1780 -        sprintf (buf + len,
1781 +  if(pIhw->AppData.dsl_modulation > 5)
1782 +    seq_printf (m,
1783                   "\tBitSwap:\t\t%u\tUS Max Attainable Bit Rate: %u bps\n",
1784                     (unsigned int)(usBitswap && dsBitswap), us_maxRate);
1785 -    else
1786 -      len +=
1787 -        sprintf (buf + len,
1788 +  else
1789 +    seq_printf (m,
1790                   "\tBitSwap:\t\t%u\tUS Max Attainable Bit Rate:\tn/a\n",
1791                     (unsigned int)(usBitswap && dsBitswap));
1792 -  }
1793
1794  #if 1 // TR69
1795 -  if(len<=limit)
1796 -    len +=
1797 -      sprintf (buf + len, "\tAnnex: \t\t\t%s\tpsd_mask_qualifier: 0x%04x\n",
1798 +  seq_printf (m, "\tAnnex: \t\t\t%s\tpsd_mask_qualifier: 0x%04x\n",
1799               tn7dsl_AnnexFromNum(pIhw->AppData.annex_selected),
1800               pIhw->AppData.psd_mask_qualifier);
1801
1802  //  UR8_MERGE_START CQ10979   Jack Zhang
1803  //  UR8_MERGE_START CQ10978   Jack Zhang
1804 -  if(len<=limit)
1805 -    len +=
1806 -      sprintf (buf + len, "\tPower Management Status: L%d\tDS HLINSC: %d\n",
1807 +  seq_printf (m, "\tPower Management Status: L%d\tDS HLINSC: %d\n",
1808               pIhw->AppData.pwrStatus, pIhw->AppData.dsHLINSC);
1809  //  UR8_MERGE_END   CQ10978*
1810
1811 -  if(len<=limit)
1812 -    len +=
1813 -      sprintf (buf + len, "\tUS ACTPSD: \t\t%d\tDS ACTPSD: %d\n",
1814 +  seq_printf (m, "\tUS ACTPSD: \t\t%d\tDS ACTPSD: %d\n",
1815               pIhw->AppData.usACTPSD, pIhw->AppData.dsACTPSD);
1816
1817 -  if(len<=limit)
1818 -    len +=
1819 -      sprintf (buf + len, "\tTotal init. errors: \t%d\tTotal init. timeouts: %d\n",
1820 +  seq_printf (m, "\tTotal init. errors: \t%d\tTotal init. timeouts: %d\n",
1821               pIhw->AppData.totalInitErrs, pIhw->AppData.totalInitTOs);
1822
1823 -  if(len<=limit)
1824 -    len +=
1825 -      sprintf (buf + len, "\tShowtime init. errors: \t%d\tShowtime init. timeouts: %d\n",
1826 +  seq_printf (m, "\tShowtime init. errors: \t%d\tShowtime init. timeouts: %d\n",
1827               pIhw->AppData.showtimeInitErrs, pIhw->AppData.showtimeInitTOs);
1828
1829 -  if(len<=limit)
1830 -    len +=
1831 -      sprintf (buf + len, "\tLast showtime init. errors: %ld\tLast showtime init. timeouts: %ld\n",
1832 +  seq_printf (m, "\tLast showtime init. errors: %ld\tLast showtime init. timeouts: %ld\n",
1833               pIhw->AppData.lastshowInitErrs, pIhw->AppData.lastshowInitTOs);
1834  //  UR8_MERGE_END   CQ10979*
1835
1836 -  if (len<=limit)
1837 -  {
1838 -    len += sprintf(buf+len,"\tATUC ghsVid: ");
1839 -    for (i=0; i<8; i++)
1840 -      len+= sprintf(buf+len, " %02x", pIhw->AppData.ghsATUCVendorId[i]);
1841 -  }
1842 +  seq_printf(m,"\tATUC ghsVid: ");
1843 +  for (i=0; i<8; i++)
1844 +    seq_printf(m, " %02x", pIhw->AppData.ghsATUCVendorId[i]);
1845
1846 -  if (len<=limit)
1847 -  {
1848 -    len += sprintf (buf + len, "\n");
1849 -  }
1850 +  seq_printf (m, "\n");
1851
1852 -  if (len <= limit)
1853 -  {
1854 -    len +=
1855 -      sprintf (buf + len,
1856 +  seq_printf (m,
1857                 "\tT1413Vid: %02x %02x\t\tT1413Rev: %02x\t\tVendorRev: %02x\n",
1858                 pIhw->AppData.t1413ATUC.VendorId[0],
1859                 pIhw->AppData.t1413ATUC.VendorId[1],
1860        pIhw->AppData.t1413ATUC.t1413Revision,
1861        pIhw->AppData.t1413ATUC.VendorRevision);
1862 -  }
1863
1864 -  if (len<=limit)
1865 -  {
1866 -    len += sprintf(buf+len,"\tATUR ghsVid: ");
1867 -    for (i=0; i<8; i++)
1868 -      len+= sprintf(buf+len, " %02x", pIhw->AppData.ghsATURVendorId[i]);
1869 -  }
1870 +  seq_printf(m,"\tATUR ghsVid: ");
1871 +  for (i=0; i<8; i++)
1872 +    seq_printf(m, " %02x", pIhw->AppData.ghsATURVendorId[i]);
1873
1874 -  if (len<=limit)
1875 -  {
1876 -    len += sprintf (buf + len, "\n");
1877 -  }
1878 +  seq_printf (m, "\n");
1879
1880 -  if (len <= limit)
1881 -  {
1882 -    len +=
1883 -      sprintf (buf + len,
1884 +  seq_printf (m,
1885                 "\tT1413Vid: %02x %02x\tT1413Rev: %02x\tVendorRev: %02x\n",
1886                 pIhw->AppData.t1413ATUR.VendorId[0],
1887                 pIhw->AppData.t1413ATUR.VendorId[1],
1888        pIhw->AppData.t1413ATUR.t1413Revision,
1889        pIhw->AppData.t1413ATUR.VendorRevision);
1890 -  }
1891
1892  #endif
1893    /*
1894     * Upstream Interleaved Errors
1895     */
1896 -  if(len<=limit)
1897 -    len += sprintf(buf+len, "\n\t[Upstream (TX) Interleave path]\n");
1898 -  if(len<=limit)
1899 -    len += sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1900 +  seq_printf(m, "\n\t[Upstream (TX) Interleave path]\n");
1901 +  seq_printf(m, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1902                     (unsigned int)pIhw->AppData.usICRC_errors,
1903                     (unsigned int)pIhw->AppData.usIFEC_errors,
1904                     (unsigned int)pIhw->AppData.usINCD_error);
1905 -  if(len<=limit)
1906 -    len += sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n",
1907 +  seq_printf(m, "\tLCD: \t%u\tHEC: \t%u\n",
1908                     (unsigned int)pIhw->AppData.usILCD_errors,
1909                     (unsigned int)pIhw->AppData.usIHEC_errors);
1910    /*
1911     * Downstream Interleaved Errors
1912     */
1913 -  if(len<=limit)
1914 -    len += sprintf(buf+len, "\n\t[Downstream (RX) Interleave path]\n");
1915 -  if(len<=limit)
1916 -    len += sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1917 +  seq_printf(m, "\n\t[Downstream (RX) Interleave path]\n");
1918 +  seq_printf(m, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1919                     (unsigned int)pIhw->AppData.dsICRC_errors,
1920                     (unsigned int)pIhw->AppData.dsIFEC_errors,
1921                     (unsigned int)pIhw->AppData.dsINCD_error);
1922 -  if(len<=limit)
1923 -    len += sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n",
1924 +  seq_printf(m, "\tLCD: \t%u\tHEC: \t%u\n",
1925                     (unsigned int)pIhw->AppData.dsILCD_errors,
1926                     (unsigned int)pIhw->AppData.dsIHEC_errors);
1927    /*
1928     * Upstream Fast Errors
1929     */
1930 -  if(len<=limit)
1931 -    len += sprintf(buf+len, "\n\t[Upstream (TX) Fast path]\n");
1932 -  if(len<=limit)
1933 -    len += sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1934 +  seq_printf(m, "\n\t[Upstream (TX) Fast path]\n");
1935 +  seq_printf(m, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1936                     (unsigned int)pIhw->AppData.usFCRC_errors,
1937                     (unsigned int)pIhw->AppData.usFFEC_errors,
1938                     (unsigned int)pIhw->AppData.usFNCD_error);
1939 -  if(len<=limit)
1940 -    len += sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n",
1941 +  seq_printf(m, "\tLCD: \t%u\tHEC: \t%u\n",
1942                     (unsigned int)pIhw->AppData.usFLCD_errors,
1943                     (unsigned int)pIhw->AppData.usFHEC_errors);
1944    /*
1945     * Downstream Fast Errors
1946     */
1947 -  if(len<=limit)
1948 -    len += sprintf(buf+len, "\n\t[Downstream (RX) Fast path]\n");
1949 -  if(len<=limit)
1950 -    len += sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1951 +  seq_printf(m, "\n\t[Downstream (RX) Fast path]\n");
1952 +  seq_printf(m, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n",
1953                     (unsigned int)pIhw->AppData.dsFCRC_errors,
1954                     (unsigned int)pIhw->AppData.dsFFEC_errors,
1955                     (unsigned int)pIhw->AppData.dsFNCD_error);
1956 -  if(len<=limit)
1957 -    len += sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n",
1958 -                   (unsigned int)pIhw->AppData.dsFLCD_errors,
1959 -                   (unsigned int)pIhw->AppData.dsFHEC_errors);
1960 +  seq_printf(m, "\tLCD: \t%u\tHEC: \t%u\n",
1961 +             (unsigned int)pIhw->AppData.dsFLCD_errors,
1962 +             (unsigned int)pIhw->AppData.dsFHEC_errors);
1963
1964    /*
1965     * ATM stats upstream
1966     */
1967 -  if(len<=limit)
1968 -    len += sprintf(buf+len, "\n[ATM Stats]");
1969 -  if(len<=limit)
1970 -    len += sprintf(buf+len, "\n\t[Upstream/TX]\n");
1971 -  if(len<=limit)
1972 -    len +=
1973 -      sprintf (buf + len, "\tGood Cell Cnt:\t%u\n\tIdle Cell Cnt:\t%u\n\n",
1974 -               (unsigned int) pIhw->AppData.usAtm_count[0] +
1975 -               (unsigned int) pIhw->AppData.usAtm_count[1],
1976 -               (unsigned int) pIhw->AppData.usIdle_count[0] +
1977 -               (unsigned int) pIhw->AppData.usIdle_count[1]);
1978 -//UR8_MERGE_START CQ10700 Manjula K
1979 -  if (len <= limit)
1980 -    len +=
1981 -      sprintf (buf + len,
1982 +  seq_printf(m, "\n[ATM Stats]");
1983 +  seq_printf(m, "\n\t[Upstream/TX]\n");
1984 +  seq_printf (m, "\tGood Cell Cnt:\t%u\n\tIdle Cell Cnt:\t%u\n\n",
1985 +              (unsigned int) pIhw->AppData.usAtm_count[0] +
1986 +              (unsigned int) pIhw->AppData.usAtm_count[1],
1987 +              (unsigned int) pIhw->AppData.usIdle_count[0] +
1988 +              (unsigned int) pIhw->AppData.usIdle_count[1]);
1989 +//UR8_MERGE_START CQ10700 Manjula K
1990 +  seq_printf (m,
1991                 "\tTx Packets Dropped Count:\t%lu\n\tTx Bad Packets Count:\t%lu\n",
1992                 priv->stats.tx_dropped, priv->stats.tx_errors);
1993  //UR8_MERGE_END CQ10700
1994    /*
1995     * ATM stats downstream
1996     */
1997 -  if(len<=limit)
1998 -    len += sprintf(buf+len, "\n\t[Downstream/RX)]\n");
1999 -  if(len<=limit)
2000 -    len +=
2001 -      sprintf (buf + len,
2002 -               "\tGood Cell Cnt:\t%u\n\tIdle Cell Cnt:\t%u\n\tBad Hec Cell Cnt:\t%u\n",
2003 -               (unsigned int) pIhw->AppData.dsGood_count[0] +
2004 -               (unsigned int) pIhw->AppData.dsGood_count[1],
2005 -               (unsigned int) pIhw->AppData.dsIdle_count[0] +
2006 -               (unsigned int) pIhw->AppData.dsIdle_count[1],
2007 -               (unsigned int) pIhw->AppData.dsBadHec_count[0] +
2008 -               (unsigned int) pIhw->AppData.dsBadHec_count[1]);
2009 -  if(len<=limit)
2010 -    len += sprintf(buf+len, "\tOverflow Dropped Cell Cnt:\t%u\n",
2011 -                    (unsigned int) pIhw->AppData.dsOVFDrop_count[0] +
2012 -                    (unsigned int) pIhw->AppData.dsOVFDrop_count[1]);
2013 -
2014 - //UR8_MERGE_START CQ10700 Manjula K
2015 -  if (len <= limit)
2016 -    len +=
2017 -      sprintf (buf + len,
2018 -               "\tRx Packets Dropped Count:\t%lu\n\tRx Bad Packets Count:\t%lu\n\n",
2019 -               priv->stats.rx_dropped, priv->stats.rx_errors);
2020 +  seq_printf(m, "\n\t[Downstream/RX)]\n");
2021 +  seq_printf (m,
2022 +              "\tGood Cell Cnt:\t%u\n\tIdle Cell Cnt:\t%u\n\tBad Hec Cell Cnt:\t%u\n",
2023 +              (unsigned int) pIhw->AppData.dsGood_count[0] +
2024 +              (unsigned int) pIhw->AppData.dsGood_count[1],
2025 +              (unsigned int) pIhw->AppData.dsIdle_count[0] +
2026 +              (unsigned int) pIhw->AppData.dsIdle_count[1],
2027 +              (unsigned int) pIhw->AppData.dsBadHec_count[0] +
2028 +              (unsigned int) pIhw->AppData.dsBadHec_count[1]);
2029 +  seq_printf(m, "\tOverflow Dropped Cell Cnt:\t%u\n",
2030 +             (unsigned int) pIhw->AppData.dsOVFDrop_count[0] +
2031 +             (unsigned int) pIhw->AppData.dsOVFDrop_count[1]);
2032 +
2033 + //UR8_MERGE_START CQ10700 Manjula K
2034 +  seq_printf (m,
2035 +              "\tRx Packets Dropped Count:\t%lu\n\tRx Bad Packets Count:\t%lu\n\n",
2036 +              priv->stats.rx_dropped, priv->stats.rx_errors);
2037  //UR8_MERGE_END CQ10700
2038
2039    tn7sar_get_stats(pIhw->pOsContext);
2040 -  if(len<=limit)
2041 -    len += sprintf(buf+len, "\n[SAR AAL5 Stats]\n");
2042 -  if(len<=limit)
2043 -    len += sprintf(buf+len, "\tTx PDU's:\t%u\n\tRx PDU's:\t%u\n",
2044 -                    sarStat.txPktCnt, sarStat.rxPktCnt);
2045 -  if(len<=limit)
2046 -    len +=
2047 -      sprintf (buf + len, "\tTx Total Bytes:\t%u\n\tRx Total Bytes:\t%u\n",
2048 -               sarStat.txBytes, sarStat.rxBytes);
2049 -  if (len <= limit)
2050 -    len +=
2051 -      sprintf (buf + len,
2052 -               "\tTx Total Error Counts:\t%u\n\tRx Total Error Counts:\t%u\n\n",
2053 -               sarStat.txErrors, sarStat.rxErrors);
2054 +  seq_printf(m, "\n[SAR AAL5 Stats]\n");
2055 +  seq_printf(m, "\tTx PDU's:\t%u\n\tRx PDU's:\t%u\n",
2056 +             sarStat.txPktCnt, sarStat.rxPktCnt);
2057 +  seq_printf (m, "\tTx Total Bytes:\t%u\n\tRx Total Bytes:\t%u\n",
2058 +              sarStat.txBytes, sarStat.rxBytes);
2059 +  seq_printf (m,
2060 +              "\tTx Total Error Counts:\t%u\n\tRx Total Error Counts:\t%u\n\n",
2061 +              sarStat.txErrors, sarStat.rxErrors);
2062
2063    /*
2064     * oam loopback info
2065     */
2066 -  if(len<=limit)
2067 -    len += sprintf(buf+len, "\n[OAM Stats]\n");
2068 +  seq_printf(m, "\n[OAM Stats]\n");
2069
2070    tn7sar_get_near_end_loopback_count(&F4count, &F5count);
2071
2072 -  if(len<=limit)
2073 -    {
2074 -    len +=
2075 -      sprintf (buf + len,
2076 -               "\tNear End F5 Loop Back Count:\t%u\n\tNear End F4 Loop Back Count:\t%u\n\tFar End F5 Loop Back Count:\t%u\n\tFar End F4 Loop Back Count:\t%u\n",
2077 +  seq_printf (m,
2078 +              "\tNear End F5 Loop Back Count:\t%u\n\tNear End F4 Loop Back Count:\t%u\n\tFar End F5 Loop Back Count:\t%u\n\tFar End F4 Loop Back Count:\t%u\n",
2079                 F5count, F4count, oamFarLBCount[0] + oamFarLBCount[2],
2080                    oamFarLBCount[1] + oamFarLBCount[3]);
2081 -    }
2082
2083  #define USE_OAM_DROP_COUNT   //CQ10273
2084    //Read OAM ping responses count:
2085  #ifdef USE_OAM_DROP_COUNT
2086 -  if(len<=limit)
2087 -  {
2088 -  /*  len +=
2089 -      sprintf (buf + len,
2090 -               "\tSAR OAM Retry in 0x%X cycles, Drop Count=%d\n",
2091 -               tn7dsl_get_memory(0xa30085cc), tn7dsl_get_memory(0xa30085c4)); */
2092 +/*  seq_printf (m,
2093 +              "\tSAR OAM Retry in 0x%X cycles, Drop Count=%d\n",
2094 +              tn7dsl_get_memory(0xa30085cc), tn7dsl_get_memory(0xa30085c4)); */
2095
2096 -    len += sprintf (buf + len, "\tSAR OAM Ping Response Drop Count=%d\n",
2097 -               tn7dsl_get_memory(0xa30085b0));
2098 -  }
2099 +  seq_printf (m, "\tSAR OAM Ping Response Drop Count=%d\n",
2100 +              tn7dsl_get_memory(0xa30085b0));
2101  #endif // USE_OAM_DROP_COUNT
2102
2103 -  return len;
2104 +  return 0;
2105  }
2106
2107 -int tn7dsl_proc_modem(char* buf, char **start, off_t offset, int count,
2108 -                 int *eof, void *data)
2109 +static int tn7dsl_proc_stats_open(struct inode *inode, struct file *file)
2110  {
2111 +       return single_open(file, tn7dsl_proc_stats, PDE_DATA(inode));
2112 +}
2113
2114 -  int len = 0;
2115 -  int limit = count - 80;
2116 +int tn7dsl_proc_write_stats (struct file *fp, const char *buf, unsigned long count, void *data);
2117 +
2118 +struct file_operations tn7dsl_proc_stats_fops = {
2119 +       .owner          = THIS_MODULE,
2120 +       .open           = tn7dsl_proc_stats_open,
2121 +       .read           = seq_read,
2122 +       .llseek         = seq_lseek,
2123 +       .release        = single_release,
2124 +       .write          = tn7dsl_proc_write_stats,
2125 +};
2126
2127 +static int tn7dsl_proc_modem(struct seq_file *m, void *data)
2128 +{
2129    char *state;
2130    int tag;
2131
2132 @@ -1859,16 +1775,26 @@ int tn7dsl_proc_modem(char* buf, char **
2133
2134    if(pIhw->lConnected == 1)
2135      state = "SHOWTIME";
2136 -  if(len<=limit)
2137 -    len += sprintf(buf+len,"%s\n",state);
2138 -  if(len<=limit)
2139 -    len += sprintf(buf+len, "%d\n", dslReg);
2140 -  if(len<=limit)
2141 -    len += sprintf(buf+len, "failTrains=%d\n", pIhw->AppData.trainFails);
2142 +  seq_printf(m,"%s\n",state);
2143 +  seq_printf(m, "%d\n", dslReg);
2144 +  seq_printf(m, "failTrains=%d\n", pIhw->AppData.trainFails);
2145
2146 -  return len;
2147 +  return 0;
2148 +}
2149 +
2150 +static int tn7dsl_proc_modem_open(struct inode *inode, struct file *file)
2151 +{
2152 +       return single_open(file, tn7dsl_proc_modem, PDE_DATA(inode));
2153  }
2154
2155 +struct file_operations tn7dsl_proc_modem_fops = {
2156 +       .owner          = THIS_MODULE,
2157 +       .open           = tn7dsl_proc_modem_open,
2158 +       .read           = seq_read,
2159 +       .llseek         = seq_lseek,
2160 +       .release        = single_release,
2161 +};
2162 +
2163  /**********************************************************************
2164  **                                                                    *
2165  **  tn7dsl_hdlc_update_crc() -- Calculate CRC                         *
2166 @@ -2133,11 +2059,8 @@ static int tn7dsl_hdlc_rx_process(unsign
2167    return(ret);
2168  }
2169
2170 -int tn7dsl_proc_eoc (char *buf, char **start, off_t OffSet, int count,
2171 -                     int *eof, void *data)
2172 +static int tn7dsl_proc_eoc (struct seq_file *m, void *data)
2173  {
2174 -  int len = 0;
2175 -  int limit = count - 80;
2176    int offset[2] = {34, 0};  // point to buffer parameter data structure
2177    clearEocParm_t   peoc;
2178
2179 @@ -2146,62 +2069,49 @@ int tn7dsl_proc_eoc (char *buf, char **s
2180                                 (unsigned char *) &peoc,
2181                                 sizeof (clearEocParm_t));
2182
2183 -  if (len <= limit)
2184 -     len += sprintf(buf+len, "\nClear EOC Channel:\n\n");
2185 -  if (len <= limit)
2186 -     len += sprintf(buf+len, "  Enabled:\t%d\n", dslhal_support_byteSwap32(peoc.clearEocEnabled));
2187 -  if (len <= limit)
2188 -     len += sprintf(buf+len, "  TxBuf[0]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[0]));
2189 -  if (len <= limit)
2190 -     len += sprintf(buf+len, "  TxBuf[1]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[1]));
2191 -  if (len <= limit)
2192 -     len += sprintf(buf+len, "  TxBuf[2]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[2]));
2193 -  if (len <= limit)
2194 -     len += sprintf(buf+len, "  TxBuf[3]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[3]));
2195 -  if (len <= limit)
2196 -     len += sprintf(buf+len, "  RxBuf[0]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[0]));
2197 -  if (len <= limit)
2198 -     len += sprintf(buf+len, "  RxBuf[1]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[1]));
2199 -  if (len <= limit)
2200 -     len += sprintf(buf+len, "  RxBuf[2]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[2]));
2201 -  if (len <= limit)
2202 -     len += sprintf(buf+len, "  RxBuf[3]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[3]));
2203 -  if (len <= limit)
2204 -     len += sprintf(buf+len, "  txRdIndex:\t%d\n", dslhal_support_byteSwap32(peoc.txRdIndex));
2205 -  if (len <= limit)
2206 -     len += sprintf(buf+len, "  txWrIndex:\t%d\n", dslhal_support_byteSwap32(peoc.txWrIndex));
2207 -  if (len <= limit)
2208 -     len += sprintf(buf+len, "  rxRdIndex:\t%d\n", dslhal_support_byteSwap32(peoc.rxRdIndex));
2209 -  if (len <= limit)
2210 -     len += sprintf(buf+len, "  rxWrIndex:\t%d\n\n", dslhal_support_byteSwap32(peoc.rxWrIndex));
2211 -  if (len <= limit)
2212 -     len += sprintf(buf+len, "  TotalTxPkts:\t%d\n", EocTxTotalPackets);
2213 -  if (len <= limit)
2214 -     len += sprintf(buf+len, "  TotalRxPkts:\t%d\n", EocRxTotalPackets);
2215 -  if (len <= limit)
2216 -     len += sprintf(buf+len, "  TotalTxBytes:\t%d\n", EocTxTotalBytes);
2217 -  if (len <= limit)
2218 -     len += sprintf(buf+len, "  TotalRxBytes:\t%d\n\n", EocRxTotalBytes);
2219 -  if (len <= limit)
2220 -     len += sprintf(buf+len, "  ErrBufFull:\t%d\n", ErrEocBufFull);
2221 -  if (len <= limit)
2222 -     len += sprintf(buf+len, "  ErrBufIndx:\t%d\n", ErrEocBufIndex);
2223 -  if (len <= limit)
2224 -     len += sprintf(buf+len, "  ErrBufMax:\t%d\n", ErrEocBufMax);
2225 -  if (len <= limit)
2226 -     len += sprintf(buf+len, "  ErrMsgMax:\t%d\n", ErrEocMsgOversized);
2227 -  if (len <= limit)
2228 -     len += sprintf(buf+len, "  ErrTxHDLC:\t%d\n", ErrEocTxHdlcCRC);
2229 -  if (len <= limit)
2230 -     len += sprintf(buf+len, "  ErrRxHDLC:\t%d\n", ErrEocRxHdlcCRC);
2231 -  if (len <= limit)
2232 -     len += sprintf(buf+len, "  ErrRxSnmp:\t%d\n", ErrEocRxHdlcFraming);
2233 -  if (len <= limit)
2234 -     len += sprintf(buf+len, "  ErrRxPush:\t%d\n\n", ErrEocRxPush);
2235 +  seq_printf(m, "\nClear EOC Channel:\n\n");
2236 +  seq_printf(m, "  Enabled:\t%d\n", dslhal_support_byteSwap32(peoc.clearEocEnabled));
2237 +  seq_printf(m, "  TxBuf[0]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[0]));
2238 +  seq_printf(m, "  TxBuf[1]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[1]));
2239 +  seq_printf(m, "  TxBuf[2]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[2]));
2240 +  seq_printf(m, "  TxBuf[3]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pTxBufDesc[3]));
2241 +  seq_printf(m, "  RxBuf[0]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[0]));
2242 +  seq_printf(m, "  RxBuf[1]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[1]));
2243 +  seq_printf(m, "  RxBuf[2]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[2]));
2244 +  seq_printf(m, "  RxBuf[3]:\t0x%08x\n", dslhal_support_byteSwap32((unsigned int)peoc.pRxBufDesc[3]));
2245 +  seq_printf(m, "  txRdIndex:\t%d\n", dslhal_support_byteSwap32(peoc.txRdIndex));
2246 +  seq_printf(m, "  txWrIndex:\t%d\n", dslhal_support_byteSwap32(peoc.txWrIndex));
2247 +  seq_printf(m, "  rxRdIndex:\t%d\n", dslhal_support_byteSwap32(peoc.rxRdIndex));
2248 +  seq_printf(m, "  rxWrIndex:\t%d\n\n", dslhal_support_byteSwap32(peoc.rxWrIndex));
2249 +  seq_printf(m, "  TotalTxPkts:\t%d\n", EocTxTotalPackets);
2250 +  seq_printf(m, "  TotalRxPkts:\t%d\n", EocRxTotalPackets);
2251 +  seq_printf(m, "  TotalTxBytes:\t%d\n", EocTxTotalBytes);
2252 +  seq_printf(m, "  TotalRxBytes:\t%d\n\n", EocRxTotalBytes);
2253 +  seq_printf(m, "  ErrBufFull:\t%d\n", ErrEocBufFull);
2254 +  seq_printf(m, "  ErrBufIndx:\t%d\n", ErrEocBufIndex);
2255 +  seq_printf(m, "  ErrBufMax:\t%d\n", ErrEocBufMax);
2256 +  seq_printf(m, "  ErrMsgMax:\t%d\n", ErrEocMsgOversized);
2257 +  seq_printf(m, "  ErrTxHDLC:\t%d\n", ErrEocTxHdlcCRC);
2258 +  seq_printf(m, "  ErrRxHDLC:\t%d\n", ErrEocRxHdlcCRC);
2259 +  seq_printf(m, "  ErrRxSnmp:\t%d\n", ErrEocRxHdlcFraming);
2260 +  seq_printf(m, "  ErrRxPush:\t%d\n\n", ErrEocRxPush);
2261
2262 -  return len;
2263 +  return 0;
2264 +}
2265 +
2266 +static int tn7dsl_proc_eoc_open(struct inode *inode, struct file *file)
2267 +{
2268 +       return single_open(file, tn7dsl_proc_eoc, PDE_DATA(inode));
2269  }
2270
2271 +struct file_operations tn7dsl_proc_eoc_fops = {
2272 +       .owner          = THIS_MODULE,
2273 +       .open           = tn7dsl_proc_eoc_open,
2274 +       .read           = seq_read,
2275 +       .llseek         = seq_lseek,
2276 +       .release        = single_release,
2277 +};
2278 +
2279  int tn7dsl_clear_eoc_setup(void)
2280  {
2281    int   i;
2282 @@ -4440,14 +4350,10 @@ int tn7dsl_proc_write_stats (struct file
2283  }
2284
2285
2286 -int tn7dsl_proc_train_mode_export (char *buf, char **start, off_t offset,
2287 -                                   int count, int *eof, void *data)
2288 +static int tn7dsl_proc_train_mode_export (struct seq_file *m, void *data)
2289  {
2290
2291 -  int len = 0;
2292 -  char *cp = buf + offset;
2293    int i = 0;
2294 -  static int ctr = 0;
2295
2296    typedef struct
2297    {
2298 @@ -4528,197 +4434,185 @@ int tn7dsl_proc_train_mode_export (char
2299    }
2300
2301
2302 -    if(len <= count)
2303 +  for (i = 0; (i < num_entries) ; i++)
2304      {
2305 -        for (i = ctr; ((i < num_entries)&& (len <= count)) ; i++)
2306 -        {
2307 -      /*
2308 -       * Write the current string only if we can fit it into the buffer
2309 -       */
2310 -            if((strlen(dsl_modes[i].mode_name) + 6 + len) <= count)
2311 -        {
2312 -                len += snprintf(cp+len, (count - len), "%s\t\t\t%#x\n",
2313 -                                    dsl_modes[i].mode_name, dsl_modes[i].mode_value);
2314 -            }
2315 -            else
2316 -                break;
2317 -        }
2318 +              seq_printf(m, "%s\t\t\t%#x\n",
2319 +                         dsl_modes[i].mode_name, dsl_modes[i].mode_value);
2320      }
2321
2322 -  /*
2323 -   * Data was completely written
2324 -   */
2325 -    if (i >= num_entries)
2326 -    {
2327 -    /*
2328 -     * We are done with this
2329 -     */
2330 -        *eof = 1;
2331 -        ctr = 0;
2332 -    }
2333 -    else
2334 -    {
2335 -    /*
2336 -     * We have not been able to write the complete data, and we have to nul
2337 -     * terminate the buffer.
2338 -        */
2339 -        *(cp + len) = '\0';
2340 -
2341 -    /*
2342 -     * Save the value of the counter for the next read for the rest of the
2343 -     * data.
2344 -        */
2345 -        ctr = i;
2346 -    }
2347 -
2348 -    return len;
2349 +    return 0;
2350  }
2351
2352 -#ifndef NO_ADV_STATS
2353 -int tn7dsl_proc_SNRpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2354 +static int tn7dsl_proc_train_mode_export_open(struct inode *inode, struct file *file)
2355  {
2356 -  int len = 0;
2357 -
2358 +       return single_open(file, tn7dsl_proc_train_mode_export, PDE_DATA(inode));
2359 +}
2360
2361 +struct file_operations tn7dsl_proc_train_mode_export_fops = {
2362 +       .owner          = THIS_MODULE,
2363 +       .open           = tn7dsl_proc_train_mode_export_open,
2364 +       .read           = seq_read,
2365 +       .llseek         = seq_lseek,
2366 +       .release        = single_release,
2367 +};
2368
2369 -  int limit = count - 80;
2370 +#ifndef NO_ADV_STATS
2371 +int tn7dsl_proc_SNRpsds(struct seq_file *m, void *data)
2372 +{
2373    int i;
2374    unsigned char SNRpsds[512];
2375
2376 -  if(len<=limit)
2377 -    len += sprintf(buf+len, "\nAR7 SNRpsds:");
2378 +  seq_printf(m, "\nAR7 SNRpsds:");
2379
2380    if (dslhal_api_getSNRpsds(pIhw, SNRpsds, 1))
2381    {
2382      dgprintf(4, "dslhal_api_getSNRpsds failed!\n");
2383 -    return len;
2384 +    return -EIO;
2385    }
2386
2387    for (i=0; i<pIhw->AppData.max_ds_tones; i++)
2388    {
2389      if (!(i%16))
2390      {
2391 -      if(len <=limit)
2392 -        len += sprintf(buf+len, "\n");
2393 +      seq_printf(m, "\n");
2394      }
2395
2396 -    if(len <=limit)
2397 -      len += sprintf(buf+len, "%d ", (unsigned char)SNRpsds[i]);
2398 +    seq_printf(m, "%d ", (unsigned char)SNRpsds[i]);
2399    }
2400
2401 -  if(len <=limit)
2402 -    len += sprintf(buf+len, "\n");
2403 +  seq_printf(m, "\n");
2404
2405
2406
2407 -  return len;
2408 +  return 0;
2409  }
2410
2411 +static int tn7dsl_proc_SNRpsds_open(struct inode *inode, struct file *file)
2412 +{
2413 +       return single_open(file, tn7dsl_proc_SNRpsds, PDE_DATA(inode));
2414 +}
2415 +
2416 +struct file_operations tn7dsl_proc_SNRpsds_fops = {
2417 +       .owner          = THIS_MODULE,
2418 +       .open           = tn7dsl_proc_SNRpsds_open,
2419 +       .read           = seq_read,
2420 +       .llseek         = seq_lseek,
2421 +       .release        = single_release,
2422 +};
2423 +
2424  #endif
2425
2426  #ifndef NO_ADV_STATS
2427 -int tn7dsl_proc_QLNpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2428 +static int tn7dsl_proc_QLNpsds(struct seq_file *m, void *data)
2429  {
2430 -  int len = 0;
2431 -
2432 -  int limit = count - 80;
2433    unsigned char QLNpsds[512];
2434    int i;
2435
2436 -  if(len<=limit)
2437 -    len += sprintf(buf+len, "\nAR7 QLNpsds:");
2438 +  seq_printf(m, "\nAR7 QLNpsds:");
2439
2440    // call API instead of access internal buf directly
2441    if (dslhal_api_getQLNpsds(pIhw, QLNpsds, 0))
2442    {
2443      dgprintf(4, "dslhal_api_getQLNpsds failed!\n");
2444 -    return len;
2445 +    return -EIO;
2446    }
2447
2448    for (i=0; i<pIhw->AppData.max_ds_tones; i++)
2449    {
2450      if (!(i%16))
2451      {
2452 -      if(len <=limit)
2453 -        len += sprintf(buf+len, "\n");
2454 +      seq_printf(m, "\n");
2455      }
2456
2457 -    if(len <=limit)
2458 -      len += sprintf(buf+len, "%d ", (unsigned char)QLNpsds[i]);
2459 +    seq_printf(m, "%d ", (unsigned char)QLNpsds[i]);
2460    }
2461
2462 -  if(len <=limit)
2463 -    len += sprintf(buf+len, "\n");
2464 +  seq_printf(m, "\n");
2465
2466
2467 -  return len;
2468 +  return 0;
2469  }
2470 +
2471 +static int tn7dsl_proc_QLNpsds_open(struct inode *inode, struct file *file)
2472 +{
2473 +       return single_open(file, tn7dsl_proc_QLNpsds, PDE_DATA(inode));
2474 +}
2475 +
2476 +struct file_operations tn7dsl_proc_QLNpsds_fops = {
2477 +       .owner          = THIS_MODULE,
2478 +       .open           = tn7dsl_proc_QLNpsds_open,
2479 +       .read           = seq_read,
2480 +       .llseek         = seq_lseek,
2481 +       .release        = single_release,
2482 +};
2483 +
2484  #endif
2485
2486  //  UR8_MERGE_START CQ10979   Jack Zhang
2487  #ifdef TR69_HLIN_IN
2488  #ifndef NO_ADV_STATS
2489 -int tn7dsl_proc_HLINpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2490 +static int tn7dsl_proc_HLINpsds(struct seq_file *m, void *data)
2491  {
2492 -  int len = 0;
2493 -
2494 -  int limit = count - 80;
2495    short HLINpsds[2*512];
2496    int i;
2497
2498 -  if(len<=limit)
2499 -    len += sprintf(buf+len, "\nAR7 HLINpsds:");
2500 +  seq_printf(m, "\nAR7 HLINpsds:");
2501
2502    // call API instead of access internal buf directly
2503    if (dslhal_api_getHLINpsds(pIhw, (unsigned char *)HLINpsds, 1))
2504    {
2505      dgprintf(4, "dslhal_api_getHLINpsds failed!\n");
2506 -    return len;
2507 +    return -EIO;
2508    }
2509
2510    for (i=0; i<pIhw->AppData.max_ds_tones; i++)
2511    {
2512      if (!(i%8))
2513      {
2514 -      if(len <=limit)
2515 -        len += sprintf(buf+len, "\n");
2516 +      seq_printf(m, "\n");
2517      }
2518
2519 -    if(len <=limit)
2520 -      len += sprintf(buf+len, "(%d,%d) ", HLINpsds[2*i], HLINpsds[2*i+1]);
2521 +    seq_printf(m, "(%d,%d) ", HLINpsds[2*i], HLINpsds[2*i+1]);
2522    }
2523
2524 -  if(len <=limit)
2525 -    len += sprintf(buf+len, "\n");
2526 +  seq_printf(m, "\n");
2527
2528
2529 -  return len;
2530 +  return 0;
2531  }
2532
2533 -static int tn7dsl_proc_HLINpsdsIndx(char* buf, char **start, off_t offset, int count,int *eof, void *data, int indx)
2534 +static int tn7dsl_proc_HLINpsds_open(struct inode *inode, struct file *file)
2535  {
2536 -  int len = 0;
2537 +       return single_open(file, tn7dsl_proc_HLINpsds, PDE_DATA(inode));
2538 +}
2539
2540 -  int limit = count - 80;
2541 +struct file_operations tn7dsl_proc_HLINpsds_fops = {
2542 +       .owner          = THIS_MODULE,
2543 +       .open           = tn7dsl_proc_HLINpsds_open,
2544 +       .read           = seq_read,
2545 +       .llseek         = seq_lseek,
2546 +       .release        = single_release,
2547 +};
2548 +
2549 +static int tn7dsl_proc_HLINpsdsIndx(struct seq_file *m, void *data, int indx)
2550 +{
2551    short HLINpsds[2*512];
2552    int i;
2553    int start=0, dim=128;
2554
2555 -  if(len<=limit)
2556 -    len += sprintf(buf+len, "\nAR7 HLINpsds: (section %d)", indx);
2557 +  seq_printf(m, "\nAR7 HLINpsds: (section %d)", indx);
2558
2559    if((indx > 2) && (pIhw->AppData.max_ds_tones <= 256))
2560    {
2561 -    if(len <=limit)
2562 -      len += sprintf(buf+len, "\n[End of data]");
2563 -    return len;
2564 +    seq_printf(m, "\n[End of data]");
2565 +    return 0;
2566    }
2567
2568    // call API instead of access internal buf directly
2569    if (dslhal_api_getHLINpsds(pIhw, (unsigned char *)HLINpsds, 1))
2570    {
2571      dgprintf(4, "dslhal_api_getHLINpsds failed!\n");
2572 -    return len;
2573 +    return -EIO;
2574    }
2575
2576    start = (indx -1) * 128;
2577 @@ -4727,39 +4621,89 @@ static int tn7dsl_proc_HLINpsdsIndx(char
2578    {
2579      if (!(i%8))
2580      {
2581 -      if(len <=limit)
2582 -        len += sprintf(buf+len, "\n%d: ", i);
2583 +      seq_printf(m, "\n%d: ", i);
2584      }
2585
2586 -    if(len <=limit)
2587 -      len += sprintf(buf+len, "(%d,%d) ", HLINpsds[2*i], HLINpsds[2*i+1]);
2588 +    seq_printf(m, "(%d,%d) ", HLINpsds[2*i], HLINpsds[2*i+1]);
2589    }
2590
2591 -  if(len <=limit)
2592 -    len += sprintf(buf+len, "\n");
2593 +  seq_printf(m, "\n");
2594
2595 -  return len;
2596 +  return 0;
2597 +}
2598 +
2599 +static int tn7dsl_proc_HLINpsds1(struct seq_file *m, void *data)
2600 +{
2601 +  return tn7dsl_proc_HLINpsdsIndx(m, data, 1);
2602 +}
2603 +
2604 +static int tn7dsl_proc_HLINpsds2(struct seq_file *m, void *data)
2605 +{
2606 +  return tn7dsl_proc_HLINpsdsIndx(m, data, 2);
2607 +}
2608 +
2609 +static int tn7dsl_proc_HLINpsds3(struct seq_file *m, void *data)
2610 +{
2611 +  return tn7dsl_proc_HLINpsdsIndx(m, data, 3);
2612 +}
2613 +
2614 +static int tn7dsl_proc_HLINpsds4(struct seq_file *m, void *data)
2615 +{
2616 +  return tn7dsl_proc_HLINpsdsIndx(m, data, 4);
2617  }
2618
2619 -int tn7dsl_proc_HLINpsds1(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2620 +static int tn7dsl_proc_HLINpsds1_open(struct inode *inode, struct file *file)
2621  {
2622 -  return tn7dsl_proc_HLINpsdsIndx(buf, start, offset, count,eof, data, 1);
2623 +       return single_open(file, tn7dsl_proc_HLINpsds1, PDE_DATA(inode));
2624  }
2625
2626 -int tn7dsl_proc_HLINpsds2(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2627 +static int tn7dsl_proc_HLINpsds2_open(struct inode *inode, struct file *file)
2628  {
2629 -  return tn7dsl_proc_HLINpsdsIndx(buf, start, offset, count,eof, data, 2);
2630 +       return single_open(file, tn7dsl_proc_HLINpsds2, PDE_DATA(inode));
2631  }
2632
2633 -int tn7dsl_proc_HLINpsds3(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2634 +static int tn7dsl_proc_HLINpsds3_open(struct inode *inode, struct file *file)
2635  {
2636 -  return tn7dsl_proc_HLINpsdsIndx(buf, start, offset, count,eof, data, 3);
2637 +       return single_open(file, tn7dsl_proc_HLINpsds3, PDE_DATA(inode));
2638  }
2639
2640 -int tn7dsl_proc_HLINpsds4(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2641 +static int tn7dsl_proc_HLINpsds4_open(struct inode *inode, struct file *file)
2642  {
2643 -  return tn7dsl_proc_HLINpsdsIndx(buf, start, offset, count,eof, data, 4);
2644 +       return single_open(file, tn7dsl_proc_HLINpsds4, PDE_DATA(inode));
2645  }
2646 +
2647 +struct file_operations tn7dsl_proc_HLINpsds1_fops = {
2648 +       .owner          = THIS_MODULE,
2649 +       .open           = tn7dsl_proc_HLINpsds1_open,
2650 +       .read           = seq_read,
2651 +       .llseek         = seq_lseek,
2652 +       .release        = single_release,
2653 +};
2654 +
2655 +struct file_operations tn7dsl_proc_HLINpsds2_fops = {
2656 +       .owner          = THIS_MODULE,
2657 +       .open           = tn7dsl_proc_HLINpsds2_open,
2658 +       .read           = seq_read,
2659 +       .llseek         = seq_lseek,
2660 +       .release        = single_release,
2661 +};
2662 +
2663 +struct file_operations tn7dsl_proc_HLINpsds3_fops = {
2664 +       .owner          = THIS_MODULE,
2665 +       .open           = tn7dsl_proc_HLINpsds3_open,
2666 +       .read           = seq_read,
2667 +       .llseek         = seq_lseek,
2668 +       .release        = single_release,
2669 +};
2670 +
2671 +struct file_operations tn7dsl_proc_HLINpsds4_fops = {
2672 +       .owner          = THIS_MODULE,
2673 +       .open           = tn7dsl_proc_HLINpsds4_open,
2674 +       .read           = seq_read,
2675 +       .llseek         = seq_lseek,
2676 +       .release        = single_release,
2677 +};
2678 +
2679  #endif
2680  #endif //TR69_HLIN_IN
2681  //  UR8_MERGE_END   CQ10979*
2682 @@ -4767,64 +4711,48 @@ int tn7dsl_proc_HLINpsds4(char* buf, cha
2683  // *    UR8_MERGE_START CQ11057   Jack Zhang
2684  #ifdef TR69_PMD_IN
2685  #ifndef NO_ADV_STATS
2686 -int tn7dsl_proc_PMDus(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2687 +static int tn7dsl_proc_PMDus(struct seq_file *m, void *data)
2688  {
2689 -  int len = 0;
2690 -
2691 -  int limit = count - 80;
2692    int i;
2693    CoPMDTestParams_t  co_pmdtest_params;
2694 -
2695 -  if(len<=limit)
2696 -    len += sprintf(buf+len, "\nAR7 US PMD Test:\n");
2697 +
2698 +  seq_printf(m, "\nAR7 US PMD Test:\n");
2699
2700    // call API instead of access internal buf directly
2701    if (dslhal_api_getPMDTestus(pIhw, &co_pmdtest_params, 0) != DSLHAL_ERROR_NO_ERRORS)
2702    {
2703      dgprintf(4, "dslhal_api_getPMDTestus failed!\n");
2704 -    return len;
2705 +    return -EIO;
2706    }
2707
2708 -  if(len<=limit)
2709 -    len += sprintf(buf+len, "LATN=%d\n", co_pmdtest_params.co_latn);
2710 +  seq_printf(m, "LATN=%d\n", co_pmdtest_params.co_latn);
2711
2712 -  if(len<=limit)
2713 -    len += sprintf(buf+len, "SATN=%d\n", co_pmdtest_params.co_satn);
2714 +  seq_printf(m, "SATN=%d\n", co_pmdtest_params.co_satn);
2715
2716 -  if(len<=limit)
2717 -    len += sprintf(buf+len, "SNRM=%d\n", co_pmdtest_params.usMargin);
2718 +  seq_printf(m, "SNRM=%d\n", co_pmdtest_params.usMargin);
2719
2720 -  if(len<=limit)
2721 -    len += sprintf(buf+len, "attndr=%ld\n", co_pmdtest_params.co_attndr);
2722 +  seq_printf(m, "attndr=%ld\n", co_pmdtest_params.co_attndr);
2723
2724 -  if(len<=limit)
2725 -    len += sprintf(buf+len, "NearActatp=%d\n", co_pmdtest_params.co_near_actatp);
2726 +  seq_printf(m, "NearActatp=%d\n", co_pmdtest_params.co_near_actatp);
2727
2728 -  if(len<=limit)
2729 -    len += sprintf(buf+len, "FarActatp=%d\n", co_pmdtest_params.co_far_actatp);
2730 +  seq_printf(m, "FarActatp=%d\n", co_pmdtest_params.co_far_actatp);
2731
2732    //HLOG
2733    for (i=0; i<pIhw->AppData.max_us_tones; i++)
2734    {
2735      if (!(i%16))
2736 -    {
2737 -      if(len <=limit)
2738 -        len += sprintf(buf+len, "\nHLOG(%3d):", i);
2739 -    }
2740 -    if(len <=limit)
2741 -      len += sprintf(buf+len, " %d", co_pmdtest_params.TestParmCOHlogfMsg[i]);
2742 +      seq_printf(m, "\nHLOG(%3d):", i);
2743 +
2744 +    seq_printf(m, " %d", co_pmdtest_params.TestParmCOHlogfMsg[i]);
2745    }
2746
2747    //QLN
2748    for (i=0; i<pIhw->AppData.max_us_tones; i++)
2749    {
2750      if (!(i%16))
2751 -    {
2752 -      if(len <=limit)
2753 -        len += sprintf(buf+len, "\nQLN(%3d):", i);
2754 -    }
2755 -    if(len <=limit)
2756 -      len += sprintf(buf+len, " %d", co_pmdtest_params.TestParmCOQLNfMsg[i]);
2757 +      seq_printf(m, "\nQLN(%3d):", i);
2758 +
2759 +    seq_printf(m, " %d", co_pmdtest_params.TestParmCOQLNfMsg[i]);
2760
2761    }
2762
2763 @@ -4832,19 +4760,28 @@ int tn7dsl_proc_PMDus(char* buf, char **
2764    for (i=0; i<pIhw->AppData.max_us_tones; i++)
2765    {
2766      if (!(i%16))
2767 -    {
2768 -      if(len <=limit)
2769 -        len += sprintf(buf+len, "\nSNR(%3d):", i);
2770 -    }
2771 -    if(len <=limit)
2772 -      len += sprintf(buf+len, " %d", co_pmdtest_params.TestParmCOSNRfMsg[i]);
2773 +      seq_printf(m, "\nSNR(%3d):", i);
2774 +    seq_printf(m, " %d", co_pmdtest_params.TestParmCOSNRfMsg[i]);
2775    }
2776
2777 -  if(len <=limit)
2778 -    len += sprintf(buf+len, "\n");
2779 +  seq_printf(m, "\n");
2780
2781 -  return len;
2782 +  return 0;
2783 +}
2784 +
2785 +static int tn7dsl_proc_PMDus_open(struct inode *inode, struct file *file)
2786 +{
2787 +       return single_open(file, tn7dsl_proc_PMDus, PDE_DATA(inode));
2788  }
2789 +
2790 +struct file_operations tn7dsl_proc_PMDus_fops = {
2791 +       .owner          = THIS_MODULE,
2792 +       .open           = tn7dsl_proc_PMDus_open,
2793 +       .read           = seq_read,
2794 +       .llseek         = seq_lseek,
2795 +       .release        = single_release,
2796 +};
2797 +
2798  #endif //NO_ADV_STATS
2799  #endif //TR69_PMD_IN
2800  // *    UR8_MERGE_END   CQ11057 *
2801 --- a/tn7sar.c
2802 +++ b/tn7sar.c
2803 @@ -1401,44 +1401,70 @@ int tn7sar_oam_generation(void *privCont
2804    return 0;
2805  }
2806
2807 -int tn7sar_proc_oam_ping(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2808 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
2809 +#define PDE_DATA(inode) PDE(inode)->data
2810 +#endif
2811 +
2812 +static int tn7sar_proc_oam_ping(struct seq_file *m, void *data)
2813  {
2814 -  int len = 0;
2815    unsigned int oam_ps = oamPingStatus;
2816
2817    if( oam_ps == OAM_PING_PENDING_RECVD )
2818      oam_ps = OAM_PING_PENDING;  //jz  CQ9861: Only export the PENDING status, not internal state
2819
2820 -  len += sprintf(buf+len, "%d\n", oam_ps); //oamPingStatus);
2821 +  seq_printf(m, "%d\n", oam_ps); //oamPingStatus);
2822
2823 -  return len;
2824 +  return 0;
2825  }
2826
2827 -int tn7sar_proc_pvc_table(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2828 +static int tn7sar_proc_oam_ping_open(struct inode *inode, struct file *file)
2829 +{
2830 +       return single_open(file, tn7sar_proc_oam_ping, PDE_DATA(inode));
2831 +}
2832 +
2833 +struct file_operations tn7sar_proc_oam_ping_fops = {
2834 +       .owner          = THIS_MODULE,
2835 +       .open           = tn7sar_proc_oam_ping_open,
2836 +       .read           = seq_read,
2837 +       .llseek         = seq_lseek,
2838 +       .release        = single_release,
2839 +};
2840 +
2841 +
2842 +static int tn7sar_proc_pvc_table(struct seq_file *m, void *data)
2843  {
2844 -  int len = 0;
2845    int i;
2846
2847    for(i=0;i<16;i++)
2848    {
2849      if(pvc_result[i].bInUse)
2850      {
2851 -      len += sprintf(buf+len, "%d,%d\n", pvc_result[i].vpi,pvc_result[i].vci);
2852 +      seq_printf(m, "%d,%d\n", pvc_result[i].vpi,pvc_result[i].vci);
2853      }
2854      else
2855      {
2856 -      len += sprintf(buf+len, "0,0\n");
2857 +      seq_printf(m, "0,0\n");
2858      }
2859    }
2860 -  return len;
2861 +  return 0;
2862 +}
2863 +
2864 +static int tn7sar_proc_pvc_table_open(struct inode *inode, struct file *file)
2865 +{
2866 +       return single_open(file, tn7sar_proc_pvc_table, PDE_DATA(inode));
2867  }
2868
2869 +struct file_operations tn7sar_proc_pvc_table_fops = {
2870 +       .owner          = THIS_MODULE,
2871 +       .open           = tn7sar_proc_pvc_table_open,
2872 +       .read           = seq_read,
2873 +       .llseek         = seq_lseek,
2874 +       .release        = single_release,
2875 +};
2876
2877
2878 -int tn7sar_proc_sar_stat(char* buf, char **start, off_t offset, int count,int *eof, void *data)
2879 +static int tn7sar_proc_sar_stat(struct seq_file *m, void *data)
2880  {
2881 -  int len = 0;
2882 -  int limit = count - 80;
2883    struct atm_dev *dev;
2884    Tn7AtmPrivate *priv;
2885    int i, j, k;
2886 @@ -1447,21 +1473,19 @@ int tn7sar_proc_sar_stat(char* buf, char
2887    unsigned int *pStateBase, *pSarStat;
2888    HAL_FUNCTIONS *pHalFunc;
2889    HAL_DEVICE    *pHalDev;
2890 -  int dBytes;
2891
2892 -  dev = (struct atm_dev *)data;
2893 +  dev = (struct atm_dev *)m->private;
2894    priv = (Tn7AtmPrivate *)dev->dev_data;
2895
2896    pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc;
2897    pHalDev  = (HAL_DEVICE *)priv->pSarHalDev;
2898
2899 -  len += sprintf(buf+len, "SAR HAL Statistics");
2900 +  seq_printf(m, "SAR HAL Statistics");
2901    for(i=0;i<MAX_DMA_CHAN;i++)
2902    {
2903      if(priv->lut[i].inuse)
2904      {
2905 -      if(len<=limit)
2906 -      len += sprintf(buf+len, "\nChannel %d:\n",priv->lut[i].chanid);
2907 +      seq_printf(m, "\nChannel %d:\n",priv->lut[i].chanid);
2908        k=0;
2909        for(j=0;j<4;j++)
2910        {
2911 @@ -1474,26 +1498,16 @@ int tn7sar_proc_sar_stat(char* buf, char
2912          {
2913            if((char *)*pSarStat == NULL)
2914              break;
2915 -          if(len<=limit)
2916 -          {
2917 -            dBytes = sprintf(buf+len, "%s: ",(char *) *pSarStat);
2918 -            len += dBytes;
2919 -            k += dBytes;
2920 -          }
2921 +
2922 +          k += seq_printf(m, "%s: ",(char *) *pSarStat);
2923            pSarStat++;
2924 -          if(len<=limit)
2925 -          {
2926 -            dBytes = sprintf(buf+len, "%s;  \n",(char *) *pSarStat);
2927 -            len += dBytes;
2928 -            k += dBytes;
2929 -          }
2930 +          k += seq_printf(m, "%s;  \n",(char *) *pSarStat);
2931            pSarStat++;
2932
2933            if(k > 60)
2934            {
2935              k=0;
2936 -            if(len<=limit)
2937 -            len += sprintf(buf+len, "\n");
2938 +            seq_printf(m, "\n");
2939            }
2940          }
2941
2942 @@ -1502,9 +1516,22 @@ int tn7sar_proc_sar_stat(char* buf, char
2943      }
2944    }
2945
2946 -  return len;
2947 +  return 0;
2948  }
2949
2950 +static int tn7sar_proc_sar_stat_open(struct inode *inode, struct file *file)
2951 +{
2952 +       return single_open(file, tn7sar_proc_sar_stat, PDE_DATA(inode));
2953 +}
2954 +
2955 +struct file_operations tn7sar_proc_sar_stat_fops = {
2956 +       .owner          = THIS_MODULE,
2957 +       .open           = tn7sar_proc_sar_stat_open,
2958 +       .read           = seq_read,
2959 +       .llseek         = seq_lseek,
2960 +       .release        = single_release,
2961 +};
2962 +
2963  void tn7sar_get_sar_firmware_version(unsigned int *pdsp_version_ms, unsigned int *pdsp_version_ls)
2964  {
2965