projects / openwrt / staging / rmilecki.git / blob
? search:


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