1 /* 2 * Kernel CAPI 2.0 Module - /proc/capi handling 3 * 4 * Copyright 1999 by Carsten Paeth <calle@calle.de> 5 * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name> 6 * 7 * This software may be used and distributed according to the terms 8 * of the GNU General Public License, incorporated herein by reference. 9 * 10 */ 11 12 13 #include "kcapi.h" 14 #include <linux/proc_fs.h> 15 #include <linux/seq_file.h> 16 #include <linux/init.h> 17 18 static char * 19 cardstate2str(unsigned short cardstate) 20 { 21 switch (cardstate) { 22 case CARD_DETECTED: return "detected"; 23 case CARD_LOADING: return "loading"; 24 case CARD_RUNNING: return "running"; 25 default: return "???"; 26 } 27 } 28 29 // /proc/capi 30 // =========================================================================== 31 32 // /proc/capi/controller: 33 // cnr driver cardstate name driverinfo 34 // /proc/capi/contrstats: 35 // cnr nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt 36 // --------------------------------------------------------------------------- 37 38 static void *controller_start(struct seq_file *seq, loff_t *pos) 39 { 40 if (*pos < CAPI_MAXCONTR) 41 return &capi_cards[*pos]; 42 43 return NULL; 44 } 45 46 static void *controller_next(struct seq_file *seq, void *v, loff_t *pos) 47 { 48 ++*pos; 49 if (*pos < CAPI_MAXCONTR) 50 return &capi_cards[*pos]; 51 52 return NULL; 53 } 54 55 static void controller_stop(struct seq_file *seq, void *v) 56 { 57 } 58 59 static int controller_show(struct seq_file *seq, void *v) 60 { 61 struct capi_ctr *ctr = *(struct capi_ctr **) v; 62 63 if (!ctr) 64 return 0; 65 66 seq_printf(seq, "%d %-10s %-8s %-16s %s\n", 67 ctr->cnr, ctr->driver_name, 68 cardstate2str(ctr->cardstate), 69 ctr->name, 70 ctr->procinfo ? ctr->procinfo(ctr) : ""); 71 72 return 0; 73 } 74 75 static int contrstats_show(struct seq_file *seq, void *v) 76 { 77 struct capi_ctr *ctr = *(struct capi_ctr **) v; 78 79 if (!ctr) 80 return 0; 81 82 seq_printf(seq, "%d %lu %lu %lu %lu\n", 83 ctr->cnr, 84 ctr->nrecvctlpkt, 85 ctr->nrecvdatapkt, 86 ctr->nsentctlpkt, 87 ctr->nsentdatapkt); 88 89 return 0; 90 } 91 92 static struct seq_operations seq_controller_ops = { 93 .start = controller_start, 94 .next = controller_next, 95 .stop = controller_stop, 96 .show = controller_show, 97 }; 98 99 static struct seq_operations seq_contrstats_ops = { 100 .start = controller_start, 101 .next = controller_next, 102 .stop = controller_stop, 103 .show = contrstats_show, 104 }; 105 106 static int seq_controller_open(struct inode *inode, struct file *file) 107 { 108 return seq_open(file, &seq_controller_ops); 109 } 110 111 static int seq_contrstats_open(struct inode *inode, struct file *file) 112 { 113 return seq_open(file, &seq_contrstats_ops); 114 } 115 116 static const struct file_operations proc_controller_ops = { 117 .open = seq_controller_open, 118 .read = seq_read, 119 .llseek = seq_lseek, 120 .release = seq_release, 121 }; 122 123 static const struct file_operations proc_contrstats_ops = { 124 .open = seq_contrstats_open, 125 .read = seq_read, 126 .llseek = seq_lseek, 127 .release = seq_release, 128 }; 129 130 // /proc/capi/applications: 131 // applid l3cnt dblkcnt dblklen #ncci recvqueuelen 132 // /proc/capi/applstats: 133 // applid nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt 134 // --------------------------------------------------------------------------- 135 136 static void * 137 applications_start(struct seq_file *seq, loff_t *pos) 138 { 139 if (*pos < CAPI_MAXAPPL) 140 return &capi_applications[*pos]; 141 142 return NULL; 143 } 144 145 static void * 146 applications_next(struct seq_file *seq, void *v, loff_t *pos) 147 { 148 ++*pos; 149 if (*pos < CAPI_MAXAPPL) 150 return &capi_applications[*pos]; 151 152 return NULL; 153 } 154 155 static void 156 applications_stop(struct seq_file *seq, void *v) 157 { 158 } 159 160 static int 161 applications_show(struct seq_file *seq, void *v) 162 { 163 struct capi20_appl *ap = *(struct capi20_appl **) v; 164 165 if (!ap) 166 return 0; 167 168 seq_printf(seq, "%u %d %d %d\n", 169 ap->applid, 170 ap->rparam.level3cnt, 171 ap->rparam.datablkcnt, 172 ap->rparam.datablklen); 173 174 return 0; 175 } 176 177 static int 178 applstats_show(struct seq_file *seq, void *v) 179 { 180 struct capi20_appl *ap = *(struct capi20_appl **) v; 181 182 if (!ap) 183 return 0; 184 185 seq_printf(seq, "%u %lu %lu %lu %lu\n", 186 ap->applid, 187 ap->nrecvctlpkt, 188 ap->nrecvdatapkt, 189 ap->nsentctlpkt, 190 ap->nsentdatapkt); 191 192 return 0; 193 } 194 195 static struct seq_operations seq_applications_ops = { 196 .start = applications_start, 197 .next = applications_next, 198 .stop = applications_stop, 199 .show = applications_show, 200 }; 201 202 static struct seq_operations seq_applstats_ops = { 203 .start = applications_start, 204 .next = applications_next, 205 .stop = applications_stop, 206 .show = applstats_show, 207 }; 208 209 static int 210 seq_applications_open(struct inode *inode, struct file *file) 211 { 212 return seq_open(file, &seq_applications_ops); 213 } 214 215 static int 216 seq_applstats_open(struct inode *inode, struct file *file) 217 { 218 return seq_open(file, &seq_applstats_ops); 219 } 220 221 static const struct file_operations proc_applications_ops = { 222 .open = seq_applications_open, 223 .read = seq_read, 224 .llseek = seq_lseek, 225 .release = seq_release, 226 }; 227 228 static const struct file_operations proc_applstats_ops = { 229 .open = seq_applstats_open, 230 .read = seq_read, 231 .llseek = seq_lseek, 232 .release = seq_release, 233 }; 234 235 static void 236 create_seq_entry(char *name, mode_t mode, const struct file_operations *f) 237 { 238 struct proc_dir_entry *entry; 239 entry = create_proc_entry(name, mode, NULL); 240 if (entry) 241 entry->proc_fops = f; 242 } 243 244 // --------------------------------------------------------------------------- 245 246 static void *capi_driver_start(struct seq_file *seq, loff_t *pos) 247 { 248 read_lock(&capi_drivers_list_lock); 249 return seq_list_start(&capi_drivers, *pos); 250 } 251 252 static void *capi_driver_next(struct seq_file *seq, void *v, loff_t *pos) 253 { 254 return seq_list_next(v, &capi_drivers, pos); 255 } 256 257 static void capi_driver_stop(struct seq_file *seq, void *v) 258 { 259 read_unlock(&capi_drivers_list_lock); 260 } 261 262 static int capi_driver_show(struct seq_file *seq, void *v) 263 { 264 struct capi_driver *drv = list_entry(v, struct capi_driver, list); 265 266 seq_printf(seq, "%-32s %s\n", drv->name, drv->revision); 267 return 0; 268 } 269 270 static struct seq_operations seq_capi_driver_ops = { 271 .start = capi_driver_start, 272 .next = capi_driver_next, 273 .stop = capi_driver_stop, 274 .show = capi_driver_show, 275 }; 276 277 static int 278 seq_capi_driver_open(struct inode *inode, struct file *file) 279 { 280 int err; 281 err = seq_open(file, &seq_capi_driver_ops); 282 return err; 283 } 284 285 static const struct file_operations proc_driver_ops = { 286 .open = seq_capi_driver_open, 287 .read = seq_read, 288 .llseek = seq_lseek, 289 .release = seq_release, 290 }; 291 292 // --------------------------------------------------------------------------- 293 294 void __init 295 kcapi_proc_init(void) 296 { 297 proc_mkdir("capi", NULL); 298 proc_mkdir("capi/controllers", NULL); 299 create_seq_entry("capi/controller", 0, &proc_controller_ops); 300 create_seq_entry("capi/contrstats", 0, &proc_contrstats_ops); 301 create_seq_entry("capi/applications", 0, &proc_applications_ops); 302 create_seq_entry("capi/applstats", 0, &proc_applstats_ops); 303 create_seq_entry("capi/driver", 0, &proc_driver_ops); 304 } 305 306 void __exit 307 kcapi_proc_exit(void) 308 { 309 remove_proc_entry("capi/driver", NULL); 310 remove_proc_entry("capi/controller", NULL); 311 remove_proc_entry("capi/contrstats", NULL); 312 remove_proc_entry("capi/applications", NULL); 313 remove_proc_entry("capi/applstats", NULL); 314 remove_proc_entry("capi/controllers", NULL); 315 remove_proc_entry("capi", NULL); 316 } 317