1From 2826b9f6aa1ad2ac4c2846bbce10eb3378014555 Mon Sep 17 00:00:00 2001 2From: Jonas Gorski <jogo@openwrt.org> 3Date: Thu, 26 Sep 2013 12:28:35 +0200 4Subject: [PATCH 3/3] update proc code to fix compilation for 3.10 5 6Signed-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 2966